{
 "cells": [
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## Configuration for Colab"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 1,
   "metadata": {},
   "outputs": [],
   "source": [
    "import sys\n",
    "IN_COLAB = \"google.colab\" in sys.modules\n",
    "\n",
    "if IN_COLAB:\n",
    "    !apt install python-opengl\n",
    "    !apt install ffmpeg\n",
    "    !apt install xvfb\n",
    "    !pip install pyvirtualdisplay\n",
    "    from pyvirtualdisplay import Display\n",
    "    \n",
    "    # Start virtual display\n",
    "    dis = Display(visible=0, size=(600, 400))\n",
    "    dis.start()"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "# 07. Behavior Cloning (without HER)\n",
    "\n",
    "[A. Nair et al., \"Overcoming Exploration in Reinforcement Learning with Demonstrations.\" arXiv preprint arXiv:1709.10089, 2017.](https://arxiv.org/pdf/1709.10089.pdf)\n",
    "\n",
    "Exploration in environments with sparse rewards has been a persistent problem in reinforcement learning. Many tasks are natural to  specify with a sparse reward, and manually shaping a reward function can result in suboptimal performance. However, finding a non-zero reward is exponentially more difficult with increasing task horizon or action dimensionality. In  this  paper, the authors use demonstrations to overcome the exploration problem and successfully learn to perform long-horizon, multi-step tasks with continuous control such as stacking blocks with a robot arm.\n",
    "\n",
    "### DDPG\n",
    "For learning in high-dimentional and continous action spaces, the authors of DDPG combine the actor-critic approach with insights from the recent success of DQN. Deep DPG(DDPG) is based on the deterministic policy gradient(DPG) algorithm ([Silver et al., 2014](http://proceedings.mlr.press/v32/silver14.pdf)). Please see *03.DDPG.ipynb* for detailed description of DDPG.\n",
    "\n",
    "### Demonstration Buffer\n",
    "It maintains a second replay buffer $R_D$ where we store our the demonstration data in the same format as the original replay buffer $R$. In each minibatch, we draw extra $N_D$ examples from $R_D$ to use as off-policy replay data for the update step. These examples are included in both the actor and critic update.\n",
    "\n",
    "### Behavior Cloning Loss\n",
    "It computes only on the demonstration examples for training the actor.\n",
    "$$\n",
    "L_{BC} = \\underset{i=1}{\\overset{N_D}\\sum} \\lVert \\pi (s_i | \\theta_\\pi) - a_i \\rVert^2\n",
    "$$\n",
    "This loss is a standard loss in imitation learning, but this paper shows that using it as an auxiliary loss for RL improves learning significantly. The gradient applied to the actor parameters $\\theta_\\pi$ is:\n",
    "$$\n",
    "L_A = - \\lambda_1 \\nabla_{\\theta_{\\pi}}J + \\lambda_2 \\nabla_{\\theta_{\\pi}} L_{BC}\n",
    "$$\n",
    "Two parameters called  $\\lambda_1$ ,  $\\lambda_2$  are used to weight the contributions.\n",
    "\n",
    "### Q-Filter\n",
    "Using the above loss prevents the learned policy from improving significantly beyond the demonstration policy, as the actor is always tied back to the demonstrations. To avoid this problem, the authors apply the behavior cloning loss only to states where the critic $Q(s,a)$ determines that action of the demonstration is better than actor's action:\n",
    "$$\n",
    "L_{BC} = \\underset{i=1}{\\overset{N_D}\\sum}\\lVert \\pi (s_i | \\theta_\\pi) - a_i \\rVert^2 \\mathbb{1}_{Q(s_i, a_i) > Q(s_i, \\pi(s_i))}\n",
    "$$\n",
    "\n",
    "### Hindsight Experience Replay (HER)\n",
    "The key insight of HER is that even in failed rollouts where no reward was obtained, the agent can transform them into successful ones by assuming that a state it saw in the rollout was the actual goal. It can be used with any off-policy RL algorithm assuming that for every state we can find a goal corresponding to this state.\n",
    "However, it needs parametrized goals setting, which can be sampled the goal $g$ at the beginning of every episode, so **we don't implement it**. Please see [this paper](https://arxiv.org/pdf/1707.01495) for detailed contents."
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## Import modules"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 2,
   "metadata": {},
   "outputs": [],
   "source": [
    "import os\n",
    "import copy\n",
    "import random\n",
    "from collections import deque\n",
    "from typing import Deque, Dict, List, Tuple\n",
    "\n",
    "import gym\n",
    "import matplotlib.pyplot as plt\n",
    "import numpy as np\n",
    "import torch\n",
    "import torch.nn as nn\n",
    "import torch.nn.functional as F\n",
    "import torch.optim as optim\n",
    "\n",
    "from IPython.display import clear_output\n",
    "\n",
    "if IN_COLAB and not os.path.exists(\"demo.pkl\"):\n",
    "    # download demo.pkl\n",
    "    !wget https://raw.githubusercontent.com/mrsyee/pg-is-all-you-need/master/demo.pkl"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## Set random seed"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 3,
   "metadata": {},
   "outputs": [],
   "source": [
    "if torch.backends.cudnn.enabled:\n",
    "    torch.backends.cudnn.benchmark = False\n",
    "    torch.backends.cudnn.deterministic = True\n",
    "\n",
    "seed = 777\n",
    "torch.manual_seed(seed)\n",
    "np.random.seed(seed)\n",
    "random.seed(seed)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## Replay buffer\n",
    "Typically, people implement replay buffers with one of the following three data structures:\n",
    "\n",
    "- collections.deque\n",
    "- list\n",
    "- numpy.ndarray\n",
    "\n",
    "**deque** is very easy to handle once you initialize its maximum length (e.g. deque(maxlen=buffer_size)). However, the indexing operation of deque gets terribly slow as it grows up because it is [internally doubly linked list](https://wiki.python.org/moin/TimeComplexity#collections.deque). On the other hands, **list** is an array, so it is relatively faster than deque when you sample batches at every step. Its amortized cost of Get item is [O(1)](https://wiki.python.org/moin/TimeComplexity#list).\n",
    "\n",
    "Last but not least, let's see **numpy.ndarray**. numpy.ndarray is even faster than list due to the fact that it is [a homogeneous array of fixed-size items](https://docs.scipy.org/doc/numpy/reference/generated/numpy.ndarray.html#numpy.ndarray), so you can get the benefits of [locality of reference](https://en.wikipedia.org/wiki/Locality_of_reference), . Whereas list is an array of pointers to objects, even when all of them are of the same type.\n",
    "\n",
    "Here, we are going to implement a replay buffer using numpy.ndarray.\n",
    "\n",
    "In addition, we add `extend` method to store multi transitions like demonstration.\n",
    "\n",
    "Reference: \n",
    "- [OpenAI spinning-up](https://github.com/openai/spinningup/blob/master/spinup/algos/sac/sac.py#L10)\n",
    "- [rainbow-is-all-you-need](https://render.githubusercontent.com/view/ipynb?commit=032d11277cf2436853478a69ca5a4aba03202598&enc_url=68747470733a2f2f7261772e67697468756275736572636f6e74656e742e636f6d2f437572742d5061726b2f7261696e626f772d69732d616c6c2d796f752d6e6565642f303332643131323737636632343336383533343738613639636135613461626130333230323539382f30312e64716e2e6970796e62&nwo=Curt-Park%2Frainbow-is-all-you-need&path=01.dqn.ipynb&repository_id=191133946&repository_type=Repository#Replay-buffer)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 4,
   "metadata": {},
   "outputs": [],
   "source": [
    "class ReplayBuffer:\n",
    "    \"\"\"A simple numpy replay buffer.\"\"\"\n",
    "\n",
    "    def __init__(self, obs_dim: int, size: int, batch_size: int = 32):\n",
    "        \"\"\"Initialize.\"\"\"\n",
    "        self.obs_buf = np.zeros([size, obs_dim], dtype=np.float32)\n",
    "        self.next_obs_buf = np.zeros([size, obs_dim], dtype=np.float32)\n",
    "        self.acts_buf = np.zeros([size], dtype=np.float32)\n",
    "        self.rews_buf = np.zeros([size], dtype=np.float32)\n",
    "        self.done_buf = np.zeros([size], dtype=np.float32)\n",
    "        self.max_size, self.batch_size = size, batch_size\n",
    "        self.ptr, self.size, = 0, 0\n",
    "\n",
    "    def store(\n",
    "        self,\n",
    "        obs: np.ndarray,\n",
    "        act: np.ndarray, \n",
    "        rew: float, \n",
    "        next_obs: np.ndarray, \n",
    "        done: bool,\n",
    "    ):\n",
    "        \"\"\"Store the transition in buffer.\"\"\"\n",
    "        self.obs_buf[self.ptr] = obs\n",
    "        self.next_obs_buf[self.ptr] = next_obs\n",
    "        self.acts_buf[self.ptr] = act\n",
    "        self.rews_buf[self.ptr] = rew\n",
    "        self.done_buf[self.ptr] = done\n",
    "        self.ptr = (self.ptr + 1) % self.max_size\n",
    "        self.size = min(self.size + 1, self.max_size)\n",
    "        \n",
    "    def extend(\n",
    "        self, \n",
    "        transitions: List[Tuple],\n",
    "    ):\n",
    "        \"\"\"Store the multi transitions in buffer.\"\"\"\n",
    "        for transition in transitions:\n",
    "            self.store(*transition)\n",
    "\n",
    "    def sample_batch(self) -> Dict[str, np.ndarray]:\n",
    "        \"\"\"Randomly sample a batch of experiences from memory.\"\"\"\n",
    "        idxs = np.random.choice(self.size, size=self.batch_size, replace=False)\n",
    "        return dict(obs=self.obs_buf[idxs],\n",
    "                    next_obs=self.next_obs_buf[idxs],\n",
    "                    acts=self.acts_buf[idxs],\n",
    "                    rews=self.rews_buf[idxs],\n",
    "                    done=self.done_buf[idxs])\n",
    "\n",
    "    def __len__(self) -> int:\n",
    "        return self.size"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## OU Noise\n",
    "*Ornstein-Uhlenbeck* process generates temporally correlated exploration, and it effectively copes with physical control problems of inertia.\n",
    "\n",
    "$$\n",
    "dx_t = \\theta(\\mu - x_t) dt + \\sigma dW_t\n",
    "$$\n",
    "\n",
    "Reference: \n",
    "- [Udacity github](https://github.com/udacity/deep-reinforcement-learning/blob/master/ddpg-pendulum/ddpg_agent.py)\n",
    "- [Wiki](https://en.wikipedia.org/wiki/Ornstein%E2%80%93Uhlenbeck_process)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 5,
   "metadata": {},
   "outputs": [],
   "source": [
    "class OUNoise:\n",
    "    \"\"\"Ornstein-Uhlenbeck process.\n",
    "    Taken from Udacity deep-reinforcement-learning github repository:\n",
    "    https://github.com/udacity/deep-reinforcement-learning/blob/master/\n",
    "    ddpg-pendulum/ddpg_agent.py\n",
    "    \"\"\"\n",
    "\n",
    "    def __init__(\n",
    "        self, \n",
    "        size: int, \n",
    "        mu: float = 0.0, \n",
    "        theta: float = 0.15, \n",
    "        sigma: float = 0.2,\n",
    "    ):\n",
    "        \"\"\"Initialize parameters and noise process.\"\"\"\n",
    "        self.state = np.float64(0.0)\n",
    "        self.mu = mu * np.ones(size)\n",
    "        self.theta = theta\n",
    "        self.sigma = sigma\n",
    "        self.reset()\n",
    "\n",
    "    def reset(self):\n",
    "        \"\"\"Reset the internal state (= noise) to mean (mu).\"\"\"\n",
    "        self.state = copy.copy(self.mu)\n",
    "\n",
    "    def sample(self) -> np.ndarray:\n",
    "        \"\"\"Update internal state and return it as a noise sample.\"\"\"\n",
    "        x = self.state\n",
    "        dx = self.theta * (self.mu - x) + self.sigma * np.array(\n",
    "            [random.random() for _ in range(len(x))]\n",
    "        )\n",
    "        self.state = x + dx\n",
    "        return self.state"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## Network\n",
    "We are going to use two separated networks for actor and critic. The actor network has three fully connected layers and three non-linearity functions, *ReLU* for hidden layers and *tanh* for the output layer. On the other hand, the critic network has three fully connected layers, but it used two activation functions for hidden layers *ReLU*. Plus, its input sizes of critic network are sum of state sizes and action sizes. One thing to note is that we initialize the final layer's weights and biases so that they are *uniformly distributed.*"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 6,
   "metadata": {},
   "outputs": [],
   "source": [
    "class Actor(nn.Module):\n",
    "    def __init__(\n",
    "        self, \n",
    "        in_dim: int, \n",
    "        out_dim: int,\n",
    "        init_w: float = 3e-3,\n",
    "    ):\n",
    "        \"\"\"Initialize.\"\"\"\n",
    "        super(Actor, self).__init__()\n",
    "        \n",
    "        self.hidden1 = nn.Linear(in_dim, 128)\n",
    "        self.hidden2 = nn.Linear(128, 128)\n",
    "        self.out = nn.Linear(128, out_dim)\n",
    "        \n",
    "        self.out.weight.data.uniform_(-init_w, init_w)\n",
    "        self.out.bias.data.uniform_(-init_w, init_w)\n",
    "\n",
    "    def forward(self, state: torch.Tensor) -> torch.Tensor:\n",
    "        \"\"\"Forward method implementation.\"\"\"\n",
    "        x = F.relu(self.hidden1(state))\n",
    "        x = F.relu(self.hidden2(x))\n",
    "        action = self.out(x).tanh()\n",
    "        \n",
    "        return action\n",
    "    \n",
    "    \n",
    "class Critic(nn.Module):\n",
    "    def __init__(\n",
    "        self, \n",
    "        in_dim: int, \n",
    "        init_w: float = 3e-3,\n",
    "    ):\n",
    "        \"\"\"Initialize.\"\"\"\n",
    "        super(Critic, self).__init__()\n",
    "        \n",
    "        self.hidden1 = nn.Linear(in_dim, 128)\n",
    "        self.hidden2 = nn.Linear(128, 128)\n",
    "        self.out = nn.Linear(128, 1)\n",
    "        \n",
    "        self.out.weight.data.uniform_(-init_w, init_w)\n",
    "        self.out.bias.data.uniform_(-init_w, init_w)\n",
    "\n",
    "    def forward(\n",
    "        self, state: torch.Tensor, action: torch.Tensor\n",
    "    ) -> torch.Tensor:\n",
    "        \"\"\"Forward method implementation.\"\"\"\n",
    "        x = torch.cat((state, action), dim=-1)\n",
    "        x = F.relu(self.hidden1(x))\n",
    "        x = F.relu(self.hidden2(x))\n",
    "        value = self.out(x)\n",
    "        \n",
    "        return value"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## BC Agent\n",
    "Here is a summary of BCAgent class.\n",
    "\n",
    "| Method           | Note                                                 |\n",
    "|---               |---                                                  |\n",
    "|select_action     | select an action from the input state.               |\n",
    "|step              | take an action and return the response of the env.   |\n",
    "|update_model      | update the model by gradient descent.                |\n",
    "|train             | train the agent during num_frames.                   |\n",
    "|test              | test the agent (1 episode).                          |\n",
    "|\\_plot              | plot the training progresses.                        |\n",
    "|\\_target_soft_update| soft update from the local model to the target model.|"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 7,
   "metadata": {},
   "outputs": [],
   "source": [
    "class BCAgent:\n",
    "    \"\"\"BCAgent interacting with environment.\n",
    "    \n",
    "    Attribute:\n",
    "        env (gym.Env): openAI Gym environment\n",
    "        actor (nn.Module): target actor model to select actions\n",
    "        actor_target (nn.Module): actor model to predict next actions\n",
    "        actor_optimizer (Optimizer): optimizer for training actor\n",
    "        critic (nn.Module): critic model to predict state values\n",
    "        critic_target (nn.Module): target critic model to predict state values\n",
    "        critic_optimizer (Optimizer): optimizer for training critic\n",
    "        memory (ReplayBuffer): replay memory to store transitions\n",
    "        demo_memory (ReplayBuffer): replay memory for demonstration\n",
    "        batch_size (int): batch size for sampling\n",
    "        gamma (float): discount factor\n",
    "        tau (float): parameter for soft target update\n",
    "        initial_random_steps (int): initial random action steps\n",
    "        lambda1 (float): weight for policy gradient loss\n",
    "        lambda2 (float): weight for behavior cloning loss\n",
    "        noise (OUNoise): noise generator for exploration\n",
    "        device (torch.device): cpu / gpu\n",
    "        transition (list): temporory storage for the recent transition\n",
    "        total_step (int): total step numbers\n",
    "        is_test (bool): flag to show the current mode (train / test)\n",
    "    \"\"\"\n",
    "    def __init__(\n",
    "        self,\n",
    "        env: gym.Env,\n",
    "        memory_size: int,\n",
    "        batch_size: int,\n",
    "        demo_batch_size: int,\n",
    "        ou_noise_theta: float,\n",
    "        ou_noise_sigma: float,\n",
    "        demo: list,\n",
    "        gamma: float = 0.99,\n",
    "        tau: float = 5e-3,\n",
    "        initial_random_steps: int = 1e4,\n",
    "        # loss parameters\n",
    "        lambda1: float = 1e-3,\n",
    "        lambda2: int = 1.0\n",
    "    ):\n",
    "        \"\"\"Initialize.\"\"\"\n",
    "        obs_dim = env.observation_space.shape[0]\n",
    "        action_dim = env.action_space.shape[0]\n",
    "\n",
    "        self.env = env\n",
    "        self.batch_size = batch_size\n",
    "        self.gamma = gamma\n",
    "        self.tau = tau\n",
    "        self.initial_random_steps = initial_random_steps\n",
    "        \n",
    "        # loss parameters\n",
    "        self.lambda1 = lambda1\n",
    "        self.lambda2 = lambda2 / demo_batch_size\n",
    "\n",
    "        # buffer\n",
    "        self.memory = ReplayBuffer(obs_dim, memory_size, batch_size) \n",
    "        \n",
    "        # demo buffer\n",
    "        self.demo_memory = ReplayBuffer(obs_dim, len(demo), demo_batch_size)\n",
    "        self.demo_memory.extend(demo) \n",
    "            \n",
    "        # noise\n",
    "        self.noise = OUNoise(\n",
    "            action_dim,\n",
    "            theta=ou_noise_theta,\n",
    "            sigma=ou_noise_sigma,\n",
    "        )\n",
    "\n",
    "        # device: cpu / gpu\n",
    "        self.device = torch.device(\n",
    "            \"cuda\" if torch.cuda.is_available() else \"cpu\"\n",
    "        )\n",
    "        print(self.device)\n",
    "\n",
    "        # networks\n",
    "        self.actor = Actor(obs_dim, action_dim).to(self.device)\n",
    "        self.actor_target = Actor(obs_dim, action_dim).to(self.device)\n",
    "        self.actor_target.load_state_dict(self.actor.state_dict())\n",
    "        \n",
    "        self.critic = Critic(obs_dim + action_dim).to(self.device)\n",
    "        self.critic_target = Critic(obs_dim + action_dim).to(self.device)\n",
    "        self.critic_target.load_state_dict(self.critic.state_dict())\n",
    "\n",
    "        # optimizer\n",
    "        self.actor_optimizer = optim.Adam(self.actor.parameters(), lr=3e-4)\n",
    "        self.critic_optimizer = optim.Adam(self.critic.parameters(), lr=1e-3)\n",
    "        \n",
    "        # transition to store in memory\n",
    "        self.transition = list()\n",
    "        \n",
    "        # total steps count\n",
    "        self.total_step = 0\n",
    "\n",
    "        # mode: train / test\n",
    "        self.is_test = False\n",
    "    \n",
    "    def select_action(self, state: np.ndarray) -> np.ndarray:\n",
    "        \"\"\"Select an action from the input state.\"\"\"\n",
    "        # if initial random action should be conducted\n",
    "        if self.total_step < self.initial_random_steps and not self.is_test:\n",
    "            selected_action = self.env.action_space.sample()\n",
    "        else:\n",
    "            selected_action = self.actor(\n",
    "                torch.FloatTensor(state).to(self.device)\n",
    "            ).detach().cpu().numpy()\n",
    "        \n",
    "        # add noise for exploration during training\n",
    "        if not self.is_test:\n",
    "            noise = self.noise.sample()\n",
    "            selected_action = np.clip(selected_action + noise, -1.0, 1.0)\n",
    "        \n",
    "        self.transition = [state, selected_action]\n",
    "        \n",
    "        return selected_action\n",
    "    \n",
    "    def step(self, action: np.ndarray) -> Tuple[np.ndarray, np.float64, bool]:\n",
    "        \"\"\"Take an action and return the response of the env.\"\"\"\n",
    "        next_state, reward, done, _ = self.env.step(action)\n",
    "        \n",
    "        if not self.is_test:\n",
    "            self.transition += [reward, next_state, done]\n",
    "            self.memory.store(*self.transition)\n",
    "    \n",
    "        return next_state, reward, done\n",
    "    \n",
    "    def update_model(self) -> torch.Tensor:\n",
    "        \"\"\"Update the model by gradient descent.\"\"\"\n",
    "        device = self.device  # for shortening the following lines\n",
    "        \n",
    "        # sample from replay buffer\n",
    "        samples = self.memory.sample_batch()\n",
    "        state = torch.FloatTensor(samples[\"obs\"]).to(device)\n",
    "        next_state = torch.FloatTensor(samples[\"next_obs\"]).to(device)\n",
    "        action = torch.FloatTensor(samples[\"acts\"].reshape(-1, 1)).to(device)\n",
    "        reward = torch.FloatTensor(samples[\"rews\"].reshape(-1, 1)).to(device)\n",
    "        done = torch.FloatTensor(samples[\"done\"].reshape(-1, 1)).to(device)\n",
    "        \n",
    "        # sample from demo buffer\n",
    "        d_samples = self.demo_memory.sample_batch()\n",
    "        d_state = torch.FloatTensor(d_samples[\"obs\"]).to(device)\n",
    "        d_next_state = torch.FloatTensor(d_samples[\"next_obs\"]).to(device)\n",
    "        d_action = torch.FloatTensor(d_samples[\"acts\"].reshape(-1, 1)).to(device)\n",
    "        d_reward = torch.FloatTensor(d_samples[\"rews\"].reshape(-1, 1)).to(device)\n",
    "        d_done = torch.FloatTensor(d_samples[\"done\"].reshape(-1, 1)).to(device)        \n",
    "        \n",
    "        masks = 1 - done\n",
    "        next_action = self.actor_target(next_state)\n",
    "        next_value = self.critic_target(next_state, next_action)\n",
    "        curr_return = reward + self.gamma * next_value * masks\n",
    "        curr_return = curr_return.to(device).detach()\n",
    "        \n",
    "        # train critic\n",
    "        values = self.critic(state, action)\n",
    "        critic_loss = F.mse_loss(values, curr_return)\n",
    "        \n",
    "        self.critic_optimizer.zero_grad()\n",
    "        critic_loss.backward()\n",
    "        self.critic_optimizer.step()\n",
    "                \n",
    "        # train actor\n",
    "        # PG loss\n",
    "        pg_loss = -self.critic(state, self.actor(state)).mean()\n",
    "    \n",
    "        # BC loss\n",
    "        pred_action = self.actor(d_state)       \n",
    "        qf_mask = torch.gt(\n",
    "            self.critic(d_state, d_action),\n",
    "            self.critic(d_state, pred_action),\n",
    "        ).to(device)\n",
    "        qf_mask = qf_mask.float()\n",
    "        n_qf_mask = int(qf_mask.sum().item())\n",
    "        \n",
    "        if n_qf_mask == 0:\n",
    "            bc_loss = torch.zeros(1, device=device)\n",
    "        else:\n",
    "            bc_loss = (\n",
    "                torch.mul(pred_action, qf_mask) - torch.mul(d_action, qf_mask)\n",
    "            ).pow(2).sum() / n_qf_mask\n",
    "            \n",
    "        actor_loss = self.lambda1 * pg_loss + self.lambda2 * bc_loss\n",
    "        \n",
    "        self.actor_optimizer.zero_grad()\n",
    "        actor_loss.backward()\n",
    "        self.actor_optimizer.step()\n",
    "        \n",
    "        # target update\n",
    "        self._target_soft_update()\n",
    "        \n",
    "        return actor_loss.data, critic_loss.data\n",
    "    \n",
    "    def train(self, num_frames: int, plotting_interval: int = 200):\n",
    "        \"\"\"Train the agent.\"\"\"\n",
    "        self.is_test = False\n",
    "        \n",
    "        state = self.env.reset()\n",
    "        actor_losses = []\n",
    "        critic_losses = []\n",
    "        scores = []\n",
    "        score = 0\n",
    "        \n",
    "        for self.total_step in range(1, num_frames + 1):\n",
    "            action = self.select_action(state)\n",
    "            next_state, reward, done = self.step(action)\n",
    "\n",
    "            state = next_state\n",
    "            score += reward\n",
    "\n",
    "            # if episode ends\n",
    "            if done:         \n",
    "                state = env.reset()\n",
    "                scores.append(score)\n",
    "                score = 0\n",
    "\n",
    "            # if training is ready\n",
    "            if (\n",
    "                len(self.memory) >= self.batch_size \n",
    "                and self.total_step > self.initial_random_steps\n",
    "            ):\n",
    "                actor_loss, critic_loss = self.update_model()\n",
    "                actor_losses.append(actor_loss)\n",
    "                critic_losses.append(critic_loss)\n",
    "            \n",
    "            # plotting\n",
    "            if self.total_step % plotting_interval == 0:\n",
    "                self._plot(\n",
    "                    self.total_step, \n",
    "                    scores, \n",
    "                    actor_losses, \n",
    "                    critic_losses,\n",
    "                )\n",
    "                \n",
    "        self.env.close()\n",
    "        \n",
    "    def test(self):\n",
    "        \"\"\"Test the agent.\"\"\"\n",
    "        self.is_test = True\n",
    "        \n",
    "        state = self.env.reset()\n",
    "        done = False\n",
    "        score = 0\n",
    "        \n",
    "        frames = []\n",
    "        while not done:\n",
    "            frames.append(self.env.render(mode=\"rgb_array\"))\n",
    "            action = self.select_action(state)\n",
    "            next_state, reward, done = self.step(action)\n",
    "\n",
    "            state = next_state\n",
    "            score += reward\n",
    "        \n",
    "        print(\"score: \", score)\n",
    "        self.env.close()\n",
    "        \n",
    "        return frames\n",
    "    \n",
    "    def _target_soft_update(self):\n",
    "        \"\"\"Soft-update: target = tau*local + (1-tau)*target.\"\"\"\n",
    "        tau = self.tau\n",
    "        \n",
    "        for t_param, l_param in zip(\n",
    "            self.actor_target.parameters(), self.actor.parameters()\n",
    "        ):\n",
    "            t_param.data.copy_(tau * l_param.data + (1.0 - tau) * t_param.data)\n",
    "            \n",
    "        for t_param, l_param in zip(\n",
    "            self.critic_target.parameters(), self.critic.parameters()\n",
    "        ):\n",
    "            t_param.data.copy_(tau * l_param.data + (1.0 - tau) * t_param.data)\n",
    "    \n",
    "    def _plot(\n",
    "        self, \n",
    "        frame_idx: int, \n",
    "        scores: List[float], \n",
    "        actor_losses: List[float], \n",
    "        critic_losses: List[float], \n",
    "    ):\n",
    "        \"\"\"Plot the training progresses.\"\"\"\n",
    "        def subplot(loc: int, title: str, values: List[float]):\n",
    "            plt.subplot(loc)\n",
    "            plt.title(title)\n",
    "            plt.plot(values)\n",
    "\n",
    "        subplot_params = [\n",
    "            (131, f\"frame {frame_idx}. score: {np.mean(scores[-10:])}\", scores),\n",
    "            (132, \"actor_loss\", actor_losses),\n",
    "            (133, \"critic_loss\", critic_losses),\n",
    "        ]\n",
    "        \n",
    "        clear_output(True)\n",
    "        plt.figure(figsize=(30, 5))\n",
    "        for loc, title, values in subplot_params:\n",
    "            subplot(loc, title, values)\n",
    "        plt.show()"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## Environment\n",
    "*ActionNormalizer* is an action wrapper class to normalize the action values ranged in (-1. 1). Thanks to this class, we can make the agent simply select action values within the zero centered range (-1, 1)."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 8,
   "metadata": {},
   "outputs": [],
   "source": [
    "class ActionNormalizer(gym.ActionWrapper):\n",
    "    \"\"\"Rescale and relocate the actions.\"\"\"\n",
    "\n",
    "    def action(self, action: np.ndarray) -> np.ndarray:\n",
    "        \"\"\"Change the range (-1, 1) to (low, high).\"\"\"\n",
    "        low = self.action_space.low\n",
    "        high = self.action_space.high\n",
    "\n",
    "        scale_factor = (high - low) / 2\n",
    "        reloc_factor = high - scale_factor\n",
    "\n",
    "        action = action * scale_factor + reloc_factor\n",
    "        action = np.clip(action, low, high)\n",
    "\n",
    "        return action\n",
    "\n",
    "    def reverse_action(self, action: np.ndarray) -> np.ndarray:\n",
    "        \"\"\"Change the range (low, high) to (-1, 1).\"\"\"\n",
    "        low = self.action_space.low\n",
    "        high = self.action_space.high\n",
    "\n",
    "        scale_factor = (high - low) / 2\n",
    "        reloc_factor = high - scale_factor\n",
    "\n",
    "        action = (action - reloc_factor) / scale_factor\n",
    "        action = np.clip(action, -1.0, 1.0)\n",
    "\n",
    "        return action"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "You can see [the code](https://github.com/openai/gym/blob/master/gym/envs/classic_control/pendulum.py) and [configurations](https://github.com/openai/gym/blob/cedecb35e3428985fd4efad738befeb75b9077f1/gym/envs/__init__.py#L81) of Pendulum-v0 from OpenAI's repository."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 9,
   "metadata": {},
   "outputs": [
    {
     "name": "stderr",
     "output_type": "stream",
     "text": [
      "/home/khkim/anaconda3/envs/pg-is-all-you-need/lib/python3.6/site-packages/gym/logger.py:30: UserWarning: \u001b[33mWARN: Box bound precision lowered by casting to float32\u001b[0m\n",
      "  warnings.warn(colorize('%s: %s'%('WARN', msg % args), 'yellow'))\n"
     ]
    }
   ],
   "source": [
    "# environment\n",
    "env_id = \"Pendulum-v0\"\n",
    "env = gym.make(env_id)\n",
    "env = ActionNormalizer(env)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## Initialize\n",
    "We make the demonstration using the well-trained agent in advance. (The given demo.pkl is created using *03.DDPG* agent.)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 10,
   "metadata": {},
   "outputs": [],
   "source": [
    "import pickle\n",
    "\n",
    "# load demo on replay memory\n",
    "demo_path = \"demo.pkl\"\n",
    "with open(demo_path, \"rb\") as f:\n",
    "    demo = pickle.load(f)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 11,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "cpu\n"
     ]
    }
   ],
   "source": [
    "# parameters\n",
    "num_frames = 50000\n",
    "memory_size = 100000\n",
    "batch_size = 1024\n",
    "demo_batch_size = 128\n",
    "ou_noise_theta = 1.0\n",
    "ou_noise_sigma = 0.1\n",
    "initial_random_steps = 10000\n",
    "\n",
    "agent = BCAgent(\n",
    "    env, \n",
    "    memory_size, \n",
    "    batch_size,\n",
    "    demo_batch_size,\n",
    "    ou_noise_theta,\n",
    "    ou_noise_sigma,\n",
    "    demo,\n",
    "    initial_random_steps=initial_random_steps,\n",
    ")"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## Train"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 12,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "image/png": "iVBORw0KGgoAAAANSUhEUgAABsQAAAE/CAYAAADxMaZGAAAABHNCSVQICAgIfAhkiAAAAAlwSFlzAAALEgAACxIB0t1+/AAAADl0RVh0U29mdHdhcmUAbWF0cGxvdGxpYiB2ZXJzaW9uIDMuMC4yLCBodHRwOi8vbWF0cGxvdGxpYi5vcmcvOIA7rQAAIABJREFUeJzs3Xl8JHWd//HXJ92ddCfpTjKZK8lcMFwCcoqweOG9rKz3rajrKuru/tZr10VX11vxXNcTVFyFVREURUEFL+SGGWAYGGBgjsyRc3L0kfTd/f398a2qVHc6Sc+ZzMzn+XjwmKSru+pb1dUzTb3r8/mKMQallFJKKaWUUkoppZRSSimljlQN8z0ApZRSSimllFJKKaWUUkoppQ4mDcSUUkoppZRSSimllFJKKaXUEU0DMaWUUkoppZRSSimllFJKKXVE00BMKaWUUkoppZRSSimllFJKHdE0EFNKKaWUUkoppZRSSimllFJHNA3ElFJKKaWUUkoppZRSSiml1BFNAzG1oIjIiSKyQURSIvKv8z0epZRSSimllFJKKaWUUkod/jQQUwvNh4C/GGOixpivz/dgqomIEZFJEZlw/vu+b5mIyBdEZNT57wsiIr7lZ4jI/SKSdv4840C89kgjIo0i8nMR6XWO9wVVyz8hIgXfezAhIsfWWM9bnNe/Y5Zt/YuIrBeRnIj8sMbyd4jIFmcbvxeR7hnG+5iI7PY9doKI3CAie0RkTERuFpETfctFRD4jIn0ikhCRW0XkFN/yTVX7VxSR3zjLnlW1bMLZz1c5y98mIqWq5dXH8L0ist05lx8TkROcx18iIneISFxEBkXk+yIS9b3uyyLypBNYPy4ib6lab8DZr37nOQ+KSHud+7xIRH7mnP8jIvJjEYnN9N4ppZRSqn7O96oXzPc4lFJKKaX2h4i8SURumWX5s0Rk836s/20icse+vl4ptfBpIKYWmtXAppkWikjgEI5lJqcbY1qd//xhyyXAy4HTgdOAvwfeBTY0AW4A/g/oAH4E3OA8vr+vnTciEjxIq74DeDMwOMPyn/neg1ZjzLaqcXUAH2GWc8nRD3wG+EH1AidE+hzwMmARsB34aY11/Duwp+qxduDXwInAMuA+7Hvoeg3wduBZzrrvBq52FxpjTnH3DYgCu4DrnGW3+/cduAiYAH7vW//dVcfnVt9+vQP4R+AlgPv6EWdxm3M8uoGnAD3Al3zrncSem23AW4H/EZHzfcs/CZwP/A0QAy4GsvXss7PdDuAYYK1z3D6BUkopdZTQ0EoppZRSanbGmB8bY17k/u7cIHycb/ntxpgTa79aKaU0EFMLiIj8GXgu8E2nquUEEfmhiHxHRH4rIpPAc50qlgdFJCkiu0TkE751rHH+MfwHZ9m4iLxbRM4RkY1O5cs3q7b7dqdKZtyp5Fm9j7vwVuArxpjdxpg+4CvA25xlFwBB4GvGmJxT/SbA8w7Aa2fkVOX8t4gMO8frYRE51VkWEZGviMgOp2LnDhGJOMte6lQpxZ1Knqf41tkrIv8hIhuBSREJiki3iPxCbEXUdtmPdpfGmLwx5mvGmDuA0j6u5vPA15kKemba1vXGmF8BozUWXwRcZ4zZZIzJA58Gni0ia90niMgx2ODu81Xrvc8Yc6UxZswYUwD+GzhRRDqdpxwD3GGM2WaMKWHDzpNnGOazgcXAL2ZY/lbg58aYydn21RlvA/Bx4P3GmEeNtdUYM+aM+yfGmN8bY9LGmHHge8AzfPv1cWPM48aYsjHmXuB2bPjlhpDvA95pjNnhrPsRY4wbiM21z8cAvzLGJI0xCeCXwCkopZRSak4H8SYlpZRSSqkFQb/vKKUOBA3E1IJhjHke9gL7vzhVLU84i94IfBZbKXMHtkrlLdgqnJcA7xGRl1et7lzgeOB1wNeA/wRegL3A/loReQ6AiLwMW0n0SmCJs/1aVUB+tznt5K4XkTW+x08BHvL9/hBTF/RPATYaY4xv+caq5fv62tm8CBuonICt6nktU+HPl4GzsRU9i7DtKstO+7yfYsONJcBvgd9UVaS9AXvs24Ey8BtnzD3A84H3iciLAUTkmSISr2Ose+PvxbYi3CQi7/EvEJGnA08DLj8A25EaP5/qe+wb2PMnM8d6ng0MGmPcY38NsNYJfUPYUOv3M7z2rcAvagVeItICvBpbNeh3ptN28AkR+ZjvS+MK579TncB4u4h80gnKZhp3zSo7Jzw9x7f8qUAReLXz+XhCRP7Z95K59vlbwEUi0uGEa68CfjfDuJRSSqkFTUQuFZGtYlsIPyoir/Ate6dzM5a77CwRuRpYhf3ONSEiH3Keu1c3KdU5tiYR+ZrYFsf9zs9NzrLFInKjs70xEbnd/Z7gbKvPGfdmEXn+ATxkSimllDqKichK5zrbHrFTKXxTbPvCO50bvUeBT4ivpaGI3Oa8/CHn+9PrROQCqZzSYtp693Jc54vIOudG8nXi65LjjGWb891ou4i8yXn8OBH5q/OaERH52f4fIaXUgaKBmDoc3GCMudOpSskaY241xjzs/L4RG948p+o1n3aeews2QPupMWbYqb66HTjTed67gc8bYx4zxhSxLfLOkJmrxJ4DrAFOwrbbu9F38aEVSPiemwBaRURqLHOXRw/Aa2dTcJ53EiDOfg44FzbeDrzXGNNnjCkZY+4yxuSwIeJNxpg/ONVNXwYi2ODM9XVjzC5jTAYbiiwxxnzKqe7ahq0sej2AMeYOY0x7HWOt17XYdn5LgHcC/yUibwCvpea3saFqeT+383tseHqaE/78F2CAZmdbrwACxphfzrYSEVmBDXs+4Ht4ABvubsaGaa8B3l/jtc3YwOuHM6z+ldgquL/6HrsNG9otxYZKb8C2dQQbhoENSp+Krch8A7aFYvW2X4gNrf5rhm1fjg1Bb/atuw0bvh7jjPsTznrq2ecHgEZsYDuKrQ789gzbVkoppRa6rdg2wW3YlsL/JyJdIvIabEvgt2DbC78UGDXGXAzsBP7euTHsi3t7k5LzXbYe/wmcB5yBbdf9dOCjzrIPArud7S3D3vhjxM6F+i/AOcaYKPBioHevjohSSimlVA3OtZwbgR3Ya2492Jtqwd7wvg37veSz/tcZY57t/OhObVIRPM2x3nrGtQi4CduBqBP4KnCTiHQ6Nyh/HbjQ+W50PrDBeemngVuw00KswN5MrZRaIDQQU4eDXf5fRORcEfmLc3dHAhtqLa56zZDv50yN31udn1dj50GKi61iGsNWAvXUGogx5jYn9IkD78Ve+Hfv1J3AXthwxYAJp7Krepm7PHUAXjsjY8yfgW9iA5lhEfmuiMSwxyuMvVhTrRv7ZcFdRxn7HviPif89WQ10u8fQOY4fwX5ZmZWIrHLu4pkQkYm5nu+M51FjTL8b4gH/gw1fAP4JW013Tz3rmmM7f8S2F/wF9oJPL/aY73a++HwRmLU1pIgswX4J+rYxxl95+F/YIHEl9n34JPBnJwDzeyX2nPwrtb0VuMpfPei0JNzuBMYPA59i6vi4lWxfNMbEjTG9wBXA31WN+zzgJ8CrfZWa/uVfwoZur/Vt2133p4wxGSesvsa37rn2+VrgCWyAG8Oem/83w34rpZRSC5ox5jrn+0rZuTjzJDZ4egf23+F1TnvhLcaYHTOsZm9vUqrXm7D/Xg8bY/Zg/02+2FlWALqA1caYgrHzcBjsjSpNwMkiEjLG9Bpjan2PVEoppZTaW0/HXov6d2PMpHOD+x3Osn5jzDeMMcW9/L4z13rr8RLgSWPM1c72fwo8jp1bHWzHpFNFJGKMGTDGuB10CjjXyvZhm0qpg0wDMXU4MFW//wT4NbDSGNOGrVSRaa+qzy7gXcaYdt9/ESdoqXds7rY3Ye+ydZ3OVDu5TcBpTsWX67Sq5fv62tkHaMzXjTFnY+drOgFbLTQCZIG1NV7Sj/2HG7DzkGFDjD7/an0/7wK2Vx3DqDGmImSZYWw7nbt4Wo0xrXM9f6bVMPUePB94hdiWfYPYC0Zf2duSeN/4vmWMOd4YswwbjAWBR7DtONcAtzvbuR7ocra7Brw5tW4Bfm2M+WzVqs8AfmbsnHFFY8wPsXcOVc8jNi3wconISuz8clfNtRtMHZ/NQJ7K969i3SJyJvbz9XZjzJ9qbPeTwIXAi4wxSd+ijTXW5/95rn0+A7jC+ZI6gf1cz3kOKaWUUguRiLxFRDb4bhY6FXtD0kpq35BUy97epFSvivU6P3c7P38J2ALc4rQAutTZ9hZspdonsDdZXSMi3SillFJK7b+VwI4Zqt335btOPeutR/V3Jpzfe4yd1uJ12Jv0B0TkJhE5yXnOh7DXYe4T2/r67fu4faXUQaCBmDocRYExY0xW7HxRb9yPdV0OfFhETgEQkTanlc00InKKiJwhIgERaQW+gg2JHnOechXwARHpcS4QfJCpVne3Yu+s/Vex8zb8i/P4nw/Aa2ckIuc4FXUhbOvILFB2Lqj8APiqiHQ7+/Q3YuePuBZ4iYg833ndB4EcMFNIeB+QEjuvRMRZ16kics5c45tl3E0iEnZ+bRSRsBsIisjLxM4zJc77/6/ADc5z34at2DvD+W899q7n/5xhO0FnOwEg4Gwn6CwLO/shIrIK+C7wP8aYcWwottK3nXdgqxDPAHY5VXg3A3caYy6tsel1wGtEZJmINIjIxUAIewHKHdsKbEvD6vnBXBcDd1XfnS0iF4rIMufnk4CPucfHGJMGfgZ8SESizjYuwbYQQEROxbaK/H/GmN/UOF4fxn7eXmCm5kPDWfdWbDvS/3Tev6dg22beWOc+rwPe4ZxDEWdcG1FKKaUOM2Jbb38P22Kw09jW0Y9gL4zsovYNSTD9JrC9vUmpXhXrxc5d1g9gjEkZYz5ojDkW287xA+LMFWaM+Ykx5pnOaw3whX3YtlJKKaVUtV3AKqk9H+q+fNepZ731qP7OBPZ7Ux+AMeZmY8wLsdX1j2O//2GMGTTGvNMY0w28C/i2iBy3j2NQSh1gGoipw9E/AZ8SkRS2Ddu1+7oiY+d/+gJwjYgksRcrLpzh6cuwYUIS2794DXCR08IGbOu53wAPO+u5yXkMY0weeDl2vog4dv6ulzuP79drReQjIvK7GcYcw/6DPI69i2UUe+cvwL8521uHbcv3BaDBGLMZeDO2x/EIthT8731jrT6GJeAibBi03XnN97FzZiAiz6q3HaKPO89UDzZYyjD1JeT12BAlhQ0Sv2CM+ZEzlrjzxWPQGDOIrYZKGmMSzliqj9VHnXVf6uxzhqk5NMLYasQJbOh3NzZcwqlw8m9nDBs0DjrH4xXY9oD/4G8J6QRrYI/1Q9j+0nHsXFqvMrYVp+ti4O5Z2hG9hdph2fOBjSIyiZ1r5Hrs3Hiuf3H2qd/Zp59gw1Gw4ecS4ErfmP2ViJ/Dfvnb4lv+Ed/yN2Dfp1HsOfwxX5XZXPv8duxnajf2y+Wx2Ao5pZRS6nDTgr14swdARP4BWyEG9jvSv4nI2c5NN8fJ1Ny1Q9h//1x7e5NSvX4KfFRElojIYuz36f9zxnqRMybBzllbAsoicqKIPM+5eSqL/c60v/O1KqWUUkqBveYyAFwmIi3ODcrPqPO11d+fDtR6wV5TOUFE3ujcUP06bJebG52bfV8mdkqNHPY6SxlARF7j3IAM9nqcQb83KbVgSI1OXEoppZRSSiml9pGIfBZ4D/bix1XA2cDVxpjvi8i7sTeG9GDnKL3YGPOgiLwMe0NSDPiMMebLIvIK7ATyPdibSv7JnZ9CRHqBdxg77+lc4/Ge61THfxFwuyJcB3zI6b7wfuw8uUuwF3CuMMZ8WkROw4Z5T8HOi3EXcIkxpn9/jpNSSimlFNg55oGvA8/CBkg/AR7Afn95pu95b/M/5nyv+jh2ntVLgGHg/4wxK2ZarzFmxvnga6z/mdi564/D3pz9XmPMHSLShZ03/Qxnve73tEdF5IvYOVvbsIHdF4wx393fY6SUOjA0EFNKKaWUUkoppZRSSimllFJHNG2ZqJRSSimllFJKKaWUUkoppY5oGogppZRSSiml1GFMRFZVzVtaaw5TpZRSSqmjnohcPsN3psvne2xKqYNPWyYqpZRSSimllFJKKaWUUkqpI5pWiCmllFJKKaWUUkoppZRSSqkjWnC+B7C/Fi9ebNasWTPfw1BKKaXULO6///4RY8yS+R6H0u9OSiml1OFAvzstHPrdSSmllFr46v3udNgHYmvWrGH9+vXzPQyllFJKzUJEdsz3GJSl352UUkqphU+/Oy0c+t1JKaWUWvjq/e6kLROVUkoppZRSSimllFJKKaXUEU0DMaWUUkoppZRSSil1WBGRlSLyFxF5VEQ2ich7nccXicgfRORJ588O53ERka+LyBYR2SgiZ83vHiillFLqUNNATCmllFJKKaWUUkodborAB40xJwPnAf8sIicDlwJ/MsYcD/zJ+R3gQuB4579LgO8c+iErpZRSaj5pIKaUUkoppZRSSimlDivGmAFjzAPOzyngMaAHeBnwI+dpPwJe7vz8MuAqY90DtItI1yEetlJKKaXmkQZiSimllFJKKaWUUuqwJSJrgDOBe4FlxpgBZ9EgsMz5uQfY5XvZbucxpZRSSh0lNBBTSimllFJKKaWUUoclEWkFfgG8zxiT9C8zxhjA7MM6LxGR9SKyfs+ePQdopEoppZSabxqIKaWUUkoppZRSSqnDjoiEsGHYj40x1zsPD7mtEJ0/h53H+4CVvpevcB6bxhjzXWPM04wxT1uyZMnBGbxSSimlDrkFF4iJyN+KyGYR2SIil879CqWUUkoppZRSSil1NBERAa4EHjPGfNW36NfAW52f3wrc4Hv8LWKdByR8rRWVUkopdRQIzvcA/EQkAHwLeCG2l/M6Efm1MebR+R2ZUkoppZRSSimllFpAngFcDDwsIhucxz4CXAZcKyL/COwAXuss+y3wd8AWIA38w6EdrlJKKaXm20KrEHs6sMUYs80YkweuAV42z2NSR6C+eIZH+5MMJ7PzPZSDplAqz7h/5bLhjidHsO3UayuXDet7x7hzywjbRybr2mapbCiX9649+11bRsgWSnU9dzJX3Kt1V7tn2yjFUnm/1nGwpPNFRiZy3u+jE7kFMdbhZJZktjDfwyCZLRBP5+d7GEopdciVy4bbn9wz67/ZSiml1NHIGHOHMUaMMacZY85w/vutMWbUGPN8Y8zxxpgXGGPGnOcbY8w/G2PWGmOeaoxZP9/7oJQ6NIqlMnduGZnvYSilFoCFFoj1ALt8v+92Hqugk5uq/VEqG/72v2/j775+O0//3J+4d9to3a/9+f27ef5XbuVV37mLXz1Ys9X4gnHd+t0898u3kslPD5vu3DrCm6+8l427EzO+/u5to7z68rt50/fv5cL/ua2ucOajv3qYS66u//8pdo2leeP37+XXG/rnfO6920Y541O3MJjYtxBzy/AEr//uPfz2kcF9ev3B9qWbN/P6794D2C9qz/3yrVx9z46Dvt1iqcwlV61nXe9YzeUXX3kfn7vpsf3ezjt+tI7v3bat5rIf3dXLV2/ZPOvrP3z9w7zr6vtrLrthQx+v/s5dezWev/3abVzx16179ZqF6Lr1u3jel2/lFd++k18+uHuvX//YQJIPXLthQYSvSqnafnR3LxdfeR+/X6D/fimllFJKKbXQfesvW3nT9+/VUEwpteACsbro5KZqf+xJ5Ujlirz8jG4ANg+l6n7tHx4dZDiV48mhFL9c4IHYQCLDZL7EQCIzbdmuMfvY6GRu2jKXWxX2yjN7yBbKpLJzV2c93Jdg2576qskAdo2nK/6czfaRSQolQ198+v7UY+eYHdeOOqvdDrUnhybod/YtlS2SzBZ5YmjioG93MJnllkeHuHXz8LRl5bJh+8gkW4b3fxz3bR9jw654zWW3PDrIjQ/P3rr/icHUjOO4c8sI63eM111pmM4XeXwwNWsgfLi4c8sIg8ks2/ZMcv0De/930s2bBrn+gT52jM39GVRKzY8do/bzObCPN4QopZRSSil1tNs2Yq8n7EnNfB1MKXV0WGiBWB+w0vf7CucxpQ6Yficguui0bhoDDfTH67/A1B/PctaqDp7SFav74vt8mczZ8dWqqBpMTAUvMxlMZAk0COcd2znnc/2vSdbxPNeAc+zrucjnbj+1j+37+pxt9dcICBeC/niGdL5EsVT2WhQOHoKxusd+oMbnYCydJ18qe0HdvjLGMJErzth6cSJbZGKW88YYG4SOTuZrfu7ckLTe1o594/b5tcLiw00yW+TYJS2csbKdZGbvPxvusXD/VEoppZRSSimllFLqSLXQArF1wPEicoyINAKvB349z2NSRxj34n5PR4TlbeG9utg/kMjQ3R4h0hhY8IFYOm8Dhlphk/vYbCFXfyLDsmgTbc0hYO6wIVcsMTKR36vAyg0k6mmD6K63nmCuFvd93r0AL/wbY7ygLpUtevt4KKoBvECsZnBqHxtMZverpd5kvkTZwMQMc8D597mWeLpA2mn9WWucbpiTzNR3buyOu4HY4V9tkcwUiIVDxCKhvQqjXX0L+HOhlFJKKaWUUkoppdSBtKACMWNMEfgX4GbgMeBaY8ym+R2VOtK4lTDdbRG62+sPxLIFG/h0t4WJhAJkFnggNukECIPJGkFHcu5AbCCepas9QjQcnPO5AMNJW3aeK5bJF+sLT6bCmLnfg6RXIbZ/gdj+VjsdDOPpAtmCPWapbNGr9Kn13h1obhVarffAfX/KBob3o63AXGFmMlskUyjNGLr522QOVL1/5bLxqjzrDWPdc2A4lTvs585KZYs2EAsH961CzAvEtGWiUkoppZRSSimllDqyLahADMAY81tjzAnGmLXGmM/O93jUkac/kaG5MUAsEqS7PVJ3lYhbLdPdHjksArG0U41Tu2Xi3AHCQCJDV1uYWDg053Pt86e2U28w4a9OMsbM+tz9bZnohiB98cyc2zrU/CFdMlvwwr94ukAmf3DPs9neA3/Lxv0JEud67yZyBefP2oGZPxCrnkNuZCJH3gm16q2QcivKSmXDnonDu394MlsgGg46FWKFvTq3y2Xj3SCgFWJKLXwi8z0CpZRSSimllFLq8LbgAjGlDraBeJbu9ggiQndbpO52cG4g0NUepikUIJNf2JUlbrgwWyu8mQIIYwwDiWxFIDZX2OCvMKq3iss9pul8ac7173/LRLvP2UKZ8fS+hWoHS19VIOYPjg52lZgbiOSK04+L/9ypDqL2xmzvXaFUrqiOq8U/v1X1+bzLt6zeCqmKirPDvG1iMlMgFgkRC4colIx3LOvhDxP35/1VSh16t24e5vO/fWy+h6GUUkoppZRSSh1WNBBTR51+p/IJbLVXqWzqagfX71w473EqxBb+HGJuy8TKC92pbIFUbvb2g+PpArlima42f8vE2cOGwYoKsfpCq4FElg5njrK55hHbnwqxYqnMYDLL8UtbgYXXNtE/nlS2WBEO1tNOcn8MJLNe1UH1tgZ9748bKO4Ld3/S+RKlcmUFk/9cmTEQi2cIhxpY3No07b2rDhPr0Tee8fZrYD/2a74VS2Um8yVnDjH7Oa33GMDUXGqdLY3aMlGpBei+7WPkirW/a7ztf9dxxW3bDvGIlFJKKaWUUkqpw5sGYuqo0x/P0t0WAaC73QZj9YQO7oX45W1hIo0NCz4Qm8zXbpk4lJy7taG7r93tYVrrnEOsomVibu6L8ul8kUSmwJmrOpzXz/4euOvclwqx4VSOUtlwzjGLgIXXHs5/7JKZygqxoYNcITaYyHDC0qgdR1U4NJjMcuySVtqbQwekZSLARNX7N1ERiNU+b/rGM/S0R+hpD3vBtH+ZK5mps2ViPMPZq+s77xYyt8IzGg5OVXLuxTxi7rE799hFDCVzM154V0odepsHU7z2irv5zI1aBaaUUkoppZRSSh0oGoipo0quWGJkIkd3uxuI2T/76qgSGUhkWNzaRFMwQCQUoFg2FOpotThf0jl7cXtkIl9xodsNX4INMmO45D5neVuEUKCBSChQV4WYW2lUT2jlbuOsVe3e62fjVYjN0OZxNm6Yc86ajorfF4q++FTFUipbJJkp0hiwfz0fzJZ+hVKZ4VSOs1bb92CgKnwbTGRZ3hamqy2yn4HY1LlTXcHk/322OcR6OpprjqMvnqYtEiIUkLqqowqlMkPJLCd3txEONRzWLRPdADAWCRGL1Nfa1M+trnv6GhsUH87VckodacbTeQA2D6XmeSRKKaWUUkoppdSRQwMxdVQZStjWiF1OZZjbOrGei/198axXURYOBQDILOAqscl8kdYmW901nJxqCekGT8csbpkxuBp0qma6neMTDQfnrhBLZlm9qBmoMxBzLr6fvrIdkbmDn/1pmehe+D+lu41IKLDg5kvqj2c4YZmt0nLnEOtsbaQtEpozKNwfw6kcxsCpPW0EG4QB33Fx55FbHgvT0x7ezznEZm6LWE/LxP54hp72MN3tNhAzZqrtYt94hhUdEWLhUF3VUYOJLGUDK9ojdg7BwzkQcz4LsXCQWHjvWyb2xzNEw0FO6ooBC69yUimllFJKKaXU/htKZqdNX6CUUkcrDcTUUcW9qO+2TIyGQ8TCwYogYCYD8Yz3ukijDcSy+YUZiBljSOdLrF3SAlSGTW4AcPyy1hlbG/YnsoQCwuLWJqC+QGwwkeF4J9SpJ7Tqd0K3VYuaWdLaNGswYYzx1rkvLRPd+a+62yN0t4cXXIVYfzzDqkXNtDQGSGWLpLJFouEgXW3hg1rB5AafPe0RlsXCFe9BMlMkUyjR1TYVRO0r//lQfW74q8JqnTeZfInRyTw9znuXzpcqWiP2xW07xVgkVNe54YY+PR0RlreFvfPwcOSGX9Gwr0JsL1sm9rRHWNFh/17TecSUOnR+dFcvay69ibHJ/JzP9d8EoJRSSimlFr5bNw/zqd88Ot/DAOw1oHM/9ye++ofN8z0UpZRaEDQQU0cVd74gt0IMbEgyV8tEYwz98Yz3unBwYVeI5YplSmXD2iWtgJ0LyjWQzNLZ0khnS9O0+Zy858QzLIuFaWiwPRBjkdCslSdu673jl9rt1RNMDHptGcM2+JllrqxcsUyhZOped7X+eIa2SIjWpiA9Hc0LqkIsX7QPS2x5AAAgAElEQVTHrtsJdZKZAslsgVg4xPK28EGtYHKDwq62CF1V4dBAcmrOvO72CMlscZ+q86BqDrFcdYWYLyyr0TLRfa96OiK+Fqf2MWMMu8cz9HREiIaDdVVHeetrj9B1uFeIeS0TfXOI7WXLxBUdEZbHwgQaRCvElDqEfrZuF1BHhbovC5ODOB6llFJKKXXgvO1/1/GDO7fP9zAA2JOyHYP++sSeeR6JUkotDBqIqaOKW23jVnoBdVW/JLNFJvMletorK8QWaiCWdirX1joB1aAv6BhMZFkWC9PqVH3VuvO8P5H12kmCrUCZ7UL7Hqf13spFzYRDDXUFJ3ZOtkaaggGWt4VnrdJzg45Ag+xTKNMfz3hhSs8CqxAbSmYxxgY0biXeoasQcwKx9jBd7ZXhkLtdt0LM/9je2p+WiVMBVrN3TrrBdjxdIJ0vsaKjue6WiX3jU6F4V1uYoWSW4gKeC3A2Uy0TQ0Tdlon7UCEWDDSwPLZ/bTGVUnvHnXPTGPj+7dsYmcjx2Zse9f5+qxV+1aoTi6fzZBZotbpSSimllFJKKbXQaCCmjir98QwdzSEv0AKc0GH2C8FugNLltkx05hDLFvbvQvpwKlsR8MzVFmlPKsdlv3ucL9+8mRs39s/4vEmn0mZptInWpuC0loldbWGi4SDFsiFXnL4P9jlToaENama+0O6uf3ksTDRcX+u6/vjUNtxKnWKpzPreMb5965aKu5fcSpjlsXBFiGeM4YGd46zvHWMwkeWGDX18+sZH+cEd23mkL+G9vs+ZgwpsGDoykSd7kMLM2fpyPzmUYtdYZVs679xqDzvBo1MhFgmxPBZhZCJHIl1gfe/YAW+bNZDI0tIYINo0Fb6525iq4It4x25fA5NUtsDSaJP3s59bMdbaFKxZsdjvqxBzA2n3MX+1VywSrKs6avd4mqXRJpqCAbraw5QN7JnIzfm6hcj9nMXCIcKhAE3BhrrnEEtkCqRyRXqcdokrOiLaMlGpebCpP8FnbnqMC750K9+7fTvv/9kGoDL8Epm5NuyMT/2Bl3zj9oM8SqWUUkqphS2RKXDDhr75HoZSSqnDQHC+B6DUodQfz1QEPWArxMbTBdL5Is2NtT8S1a0Ww04g5t6VPT6Z5+O/3sS63jH++IHn0NIUZFN/gtamIKs7W7z17B5Pc/XdOzipK8qTQxN8//btLG5t5BtvPIs/Pz7ED+/s5Vf//AxvLi6/naNpLv7BvV5bs1LZ8Iy1i+loaZz23Mm8vVDe0hRkeVuYLcMTXPHXrcQiIfoTGc5c1U7Ua7FW8PbHGMPIRN4GYk+dqhCLzTGHmL/9YTQcJJUrUiiV+cj1D/PuC9Z6rRurj6l7bJa3hUnlirzk63eweSgFwEnLozznhCXAVIjS0x6hL54hWyjTOzrJx2/YxH29YxXrbQw0kC+VaRD44qtPZ01nM9tHJjn3mEXAVNXcN/+8hQ++6ATvQqMxZtaLjrMZTmZ5YGecGzf2c8umIT520VO4+G/WeMtHJnJ85sZH+dWGfpobA3z6ZacymS9y7fpdjE/afetujxALBxmZyFdUiAG89Ft3sGM0zbOOX8yFp3bx+02DPDmUIpkp8IVXn8ZFp3UD8Ehfgq/98UkSmTz/+vzjGU7m+P4d27n0wpN4zglL2DKc4so7ern4vNWc3B1jIJFheVsYEaGrLUyuWGY8XaCjOcRAIouIDVWdzpn8duMA56/tZOvwJHsmct7789rL72ZkMsd7n388Lzp5eUXgDLbCsqs9wnAqRzJbZDiZ5eO/3sQXXn0ayWyBxmADi1oaa4aufeMZAg3CsmgTDSKEAkK/c755FZ/t4YoKsYuvvJcXnbKci89b7a3n/h1j/NcNm9jUn+TpzrkwVXFWGQAXnIqxUGDme0ZS2QLBhoaKfU3ni9y0cYALTlzKEicABCiXDT+5byc/uGM7337zWZy0PDZtXZ/77eM887jFvOS0rhm3Wc3d31anOiwaDlXMrwZw99ZRvn3rFmKREN9641ne4/2+yjuA45a2ct39u7l76yh/s7az7jEopeY2lLTzNrzvBcfztT8+WbFs1JlDzL05oFQ2vPeaB1nfO+4sz7FleKLiNX95fLji9217JgG4/ck93LRxgMteddpB2Q+llFJKqYXq3657iD88OsTJXbGa11OUUkoplwZi6qgykMiyoqMyEHMvXI9O5GleFGTzYIrGYAPHLJ4Kstw5xqpbJmYLJeLpPC/+2m0MO32Zd4ymObk7xvuu2cCaxS187y1P89bz+0cGueK2bd7vf396Nw/sGOdV37nLe+yh3YlpX+AKpTKv/+7dZAolfv7uv2EgkeWffvwAA4ls7UAsZ4O6Fqfy5/YnR7j9yRFveVdbmGiT/finskWWOpt785X3cueWUQDW+II8W/U1W4WYW0E3VSG2bc8k192/m2OXtPKeC6YHYoOJLOcd21lxXBOZAl95zencuWWEPz425D3XDeO6nUAylS3wyd9s4onhFJ986Sms6IiwcyzNaSvaOHNlB3smcnzg2g3823UPEWwQVi5q5u3PPAaAF5+ynNefs5Jv/mUL63rHKJXt/HDDqRyfeOkpvNkXolxz306+8ocn6Gxp5E3nra4IWJLZAt/96zZ+v2nQu1jZ3hyiocG+hxf79vUbf3qSGzcO8O7nrOX+HWN88LqHADh9RRun9sR49gmLWdPZQjQcYtvIJMnM1BxiACOpHO969rH8+N6d3P7kCKsWNfOM4xZz08YB7ts+xkWndXPr5mHe9r/rvLnSLr7yPm/7d20Z4TknLOHGjQP89L6dXLNuJ+ev7eTxgRQnd8e89w7ghV/9K8lsgVCggSWtTYScdnpvPHcVP7l3J7c8OkQiU0AEHvr4i4g2BdmwOw4G3nvNBkRsFV6xXGZ5W4Tr33M+qWyRnvYwoYCQyha5a+sov3tkkDc8fRWpbJFYOEhrU+3QtS+eYXksTNAJpzpbmhhxPmsJJxBqjzR689xlCyVuf3KEWDhU8X798sE+tu6Z4MMXnsRLz+h29tmed/927UOctqKNy151GuFQgA9c+xDFUpnvvPlsjDHcsKGfF59ig77RiRxfunkzv3ywj+edtJTvvPlsbxs3bhzgQz/fSGOggXc951g++KITAXjPj+/n5k32fF7fO85Jy2Mk0gUe2h0nFgnx0V89zCN9SX563056R0/kjJXtDCayZAoljlva6n1OvnzzZsrG8KJTlnPGynaS2QLRpiABb66/ynnU/vDoEO+8aj0AjcGGitDXbR3pfqY+8MITuG/7GP/4o3X86O1P55w1i6a9F0qp2d29dZRjl7SwLBauePzR/iTAtDAM4PK/bp322A0bpirAt+6ZZKsTeLm3bPzDD9dNe43/814rEHvN5Xdx+op2PnrRyfXtjFJKKaXUYcS9JrG/XXyUUkod+TQQU0eV/njGqw5xtThVYe68W//xi410tjRy5dvO8Z4zEM8QbBAWt9rwzG2ZmCmUeGwgxbATWFxx2zb64xme0hVl51jau1DtSmaLiMCN/++ZNAYaOH5ZlLHJPF+6+XHOO7aT916zwbtQ7TeeztOfyPLJl57Cmas6MDvtneODyYwXaPil3QqxxgCvedpKutrCvP2Zx5BIF7jhoX4ufGoXvSP2Apvbpq5cNqzbPs7zTlrKW89fw/m+KpFoU5BsoUy+WKYxOL1qpj+epbkxQFsk5FSTFbwKlF012rBlCyWS2aJ30fDFpyznv193Oi88eTmtTUH2TOS4/sE+JnLFiqCkywnOktkiO0fT3lirLYuFufKt5/CR6x+mUDZ85uWn0haxFXGBBuHzr3wqy2JhfrOxn6XRJs5b28kfHx3igZ3jFYHYrZv3UCiViacLXLd+V0XA8usN/XzzL1s479hFvP6cp3DmqnZO7WnjDd+9Z9p7OJDIsnZJK5deeBKFUplr7tvJcUujnHfsooqqtFgkyHAyR7FsiIZDnLGqnVee1cM7nnksJ3fHeMezjmUomeWU7hgiwuODSXY6LRjv3DJCU7CB2z70XJqCDfzigd3EwiEu+93jDCVtoDuUzNLRHOJ156zirq0jtDQFed5JSwE4e/UinnX8Yha3NrE02sTueIYzVrQDtl3X517xVF74lGX8+N6dNIUauGnjAAPxLKVoE/limY++5CmsXdrKhp1xdoxO0h/Pcl/vmNcWNBqOEg2HmMgV6Hf+Z2UwkWUia99jt7KwmjvPlSvqq1Z0Q9poOEgsHPQqB+0xr3oP4lnWdLbwrues9R47YVmUS559LOt7x/jVhn7e9oxjOGNlO48NJL3qz8cGUrzvZxu47JVP5fVPX8U3/7KFn9+/m2g46B171+7xDCLw9GMW8e1bt/K+F5xArlji5k1DvPHcVVxz307vvfjvPz7BD+/qBezfJ1dcfDa/fqifL928uWKdi1sbWf/RF5IrlvjmX7YA8O1bt/J//3iuV0nonT9V86it3zFGY6CBD7zoBC773eOMTua9v8P6fK0oATpbm/jxO8/l9Vfcw+W3buWct2kgptRsymXDnolcRfj1hu/d431m/WZr0VtPi+F6uGGYuz238tu1rnecdb3jGogppZRSSimllDqqaSCmjhoTuaJt3VbVMrG5yV40ctsMJjKFaXM19cdtazk34AqHbCiUyZcINtgL0Ocd28kVt21jIJFhZCJPrliumLsLbPjU2hjklO4277FFLY18/pX2bu5P3/iYFyT5uRe53Wowt5pnMFF77iO3Qqy5MchLT+/mpad3e8vOdapN3Cob92LcyGSOfKnMBScu8VrhuWJOmJTKFuhsbaLazrE0qxY1IyLenGVu6FE9ZxbYudAAljjragw28IozV3jLu50AZCCe4fhlUS/4cB+Pp/MMJrMVQUm1cCjAV193Rs1lIsL7X3gC73/hCd5jr/7OXdOOfe/oJGev6mB5W5jfPjwwbZ8bgw385B3n0eALPns6mtmwa7ziufF0gY4WewxDgYaKdop+0XCIjHPhNBYJEguH+Oprp/ZhSbSpohXfqkXNPD5oW0xuH0mzurPZC/7edK4N7350Vy9DSXu8BxNZutsjXHrhSdO2vSTaxNX/eG7Ncbmee9JSnnvSUtb3jtlALJHx5kzrbo/w3BOX8twTbcB26+Zh7vvfMXaPZ7zgxg2zBpyKy/5ExgnLQkTDoZpzlPVVhdg2OLPngxvmtoaD3jnqVmIMVn32+p199ws0CB/5u6fwSF+Ci75xhxdWDSezpHJFcsUS253geLsTtG0ZnuDk7hhrOlvYsCtesb7BRIYlrU1c+NTl3LFlhD2pnNcG7Zw1HfzpsSFvXDtGJzl2cQvvf+EJnNwdY+2SVl74lGW85uwVNAUDLG8L86O7ern6nh0YY7zP6buecyxX/HUbjw8mbSWhs99gP6cJXyC2YyTNykURr9q1P56pCMQagw0sbpk6n5ZGw1xzyXleC0al1Mz++49P8I0/b+HuDz+v4nvFyER+2nP3ph3vut7xGZeV6pxG8qSP/Z7ey15S9zaVUkoppdShYYyhWDaztudXSil1cOnfwOqoMRCvbBHm8irEnBBpMlcknqlsD9ifyNLtu+DlVohliyXvQvWaxS2EAkJfPOtd2E9kCl61FsBErjDrxeaejkjNUMC9yB1zXruk1c7rNJiY/lzwVYg1BWouB7w5xNywyWuh1jY9ZHKrUGa6k33XWJoVHc3ec1PZghd67K5R8TacssuWxKaHawA9znvkHgt3u+7jW4YnKBtmDcT2Vld7pCLANMbYoK+zmRUdzYynC164AXY+uBUdkYowDGBFR8RWTpWnrlyOp/N0NE9vbVnNX+3jvj+zWbmomd1jGcplw47RyYo2l65lsTBDKbdCLDetlde+cCv1BhJZL0SqXq97PuweTzORqwzE3OBxMJGtCssqP3fFUnla8Om25ARI5YqEQw2EAg3EnOO1yQnEhlK5ivdgIJHxguRqS53zcDiZ9aoXjbGfCbfizK2o3D4y6bS3nD7egUSWrvaI9xnqi2d87UQjLI+FGXSOV388y9qlrfz96d3eHHsNDcIFJy7lb9Z2csziFpa3hSmVDel8yQvFT1oeJRYO0js6STJb8PYbnLn+/IHYWJrVnS3e8euPT53fbuVd9fm7NBaecS5FpdSUv2y283i5N3g847I/T3vOO69az5pLb+LH9+44INtM54qMTU4P3JRSSiml1OHhMzc9xvH/+TuKJW3tqJRS80UDMXXU6HfCjmkVYs58YG6IlM6XiKerArF4piJICzuvyeRL3kXxWDhIV1uEgUSmomWe/yJ0ymkPN5MV7bUDsWTGjs2t/gkGGlgSbZpWgeaazE9ViM3EC7mckMcdZ09HrUDMDc+mB2LGGHaN2wox97n+0KNv3AY2fsNOxdLSaO1ArLvqAn4qa+esckMXtyqquuJnf3S3hxmIZ72x7pnIkc6XWNPZwspFEW9fXLvGMqx0Qh+/nvYIxbLxQj+wgVh7HYGYP9yI1lGls2pRM/lSmYFklh1jadYsnh6ILY01MZSYapl4IAKxpdEmRGwA5AY81WGTG8I8OTRByWkBGW2yc9G5n8WBRNZrixkNBysCR5gKtbpnaZnonpvu8drUnwCgVDbeheqM85me6XzpbGki0CAMJXPeuQk2UNrhBGI7RtPkiiX64xnWLG7xznN/NelAIktXLDxV4ZjIeMFwT3vEhpNeIJaZM9CN+T537j7HwiGOWdzCjtE0yUxVy0RnHjWwn8sdo5Os7mz23ht/G8m+OravlKpt82CKR/ps+C7OzF7+f7vt3IN9/OFRO3egfw7P/fHDu3o569N/qOu5P79/9wHZplJKKaWUOnCuvsfeKFUs11n6r5RS6oDTQEwdNWaqEJsKxEoYY5jMF0lmC151SalsGEpmvaoY8FWIFaYqxKLhEF1tYfrjGfriU20C/a3b3EqZmbgVYtUBklsh1uZrj7a8LeKFEdUmc/VUiFVWffV7x2e2CrHCtGWjk3nS+ZIXGkXDQdL5klcZli+VvQol13DKDcRmqNiJ2vaU7piSTqtJd/8fH7QXImuFd/uquy1CvlRm1Ln7fseofQ9XOxViYKudXLucCrFq7pjc8MwYY1smNs9d8VU9H9Rc3BDy3m2j5IvlmhViy2NhJvMlxifzjE7mWX4AArFQoIGl0SYG4hkGEllEqGjlCBBpDLC4tZHHBux7FQ0HaXVbJjrBzEDCbacY8uaK8wdM7jH0v882iLLnoX8OreqWie76Aa9950wVYoEGYWm0iaFktuJc3TWWptc5D3pHJ9k1lqZsYE1nM7FIkGLZVEzaPJjI0tUe9v6OsX8XZLwwd3lbmMFElmS2QCpXnPZ3UbVYxO5bMlvwgq5oOMTqzhZ6RydJ5apaJoZDJDP2GI5M2M/l6kXNLGpppCnYUNEStK8q5FdK1e8/f/nwrMtfffndvPeaDQd8u6N7UR32b9c9dMC3r5RSSimllFJKHe40EFNHjX7fhWm/FqdiazJfJFsoYwwYMzVv18hEjkKpskolFGgg2CBkCiVSuSJNwQYagw30tEfoj2crK8R8VRmpbJHWWYKOnvYI+WKZkcnKucHci+H+i9/LY03T5klypXNFRKaCu1rcSjWvZWI8Q2tT0GvL6OeGDskaFWLuHGH+CjGAJ4ZTXgi0a6yy6m04lSXQIHS21K6aCjQIy2Nh7wL+VFs9u77NboVYjfaO+8pf1QP+QKzFC77cfU1lC8TTBVYuml4httJ5rhsIpnJFimXDohn21a8y3KivQgzgtif2ALBm8fTxuOf7w30J5/faVXl7yw1khxJZlrQ21eyB3tMe4bEB+17ZecKC7EnliKcLXoWZrfKy722pKmByg2V/JVMsHPTOw1S2SNQ5j90AMZktevNkuRWUbpVWdXWo31KnnWFFhdiorRALNgjZQpl7t48BeBVidgwF78+JXJGutrBTDRekP55lIGHn7WoMNrAsFiaZLbJtz+Sc43GPGdi/i7wKsUiQNZ3N9I1nGJvIV5wnsUiQfKlMrlj2KttWL25BROhuj3iVedlCiT2pHD3t088XpdTc/Les1Joe7P4dM88DppRSSimllFJKqfmjgZg6avQnsiyNTr9wH/G1P5z0zfflziPmVU5VVZdEQgEy+XJF27budhsS7BrPcKzTvm6gomViwbuAX4sbyvRVzbuVSLttGacCk662yIyB2GS+REtjEKl1pc4RDDTQ3BhgwrnQ7rZQq/WaWNXFf7+dTki0ctHUHGIA8XSBc9YsAiorq8C2TFzc2jht/iK/7vawbw6xgldFBDCeLtDZ0ui9dweCWz3kvt87RicJNAg97RE6WxoJhxq8kMv9s1bLRO89dNYTn7THrL6WiZXt7+bS3R6hQeCOLbYdV60KMXd+rI274wAsm6FKam91O9WQA8ksy2dY54qOZq+KMRoOEguHvAqHE5ZGSWWLJH1ziEHlOeZViFW1TMwXy+SKpYrPnltNBfD0YzqAqUDMDaVnq4haFm1iOJmbmt8u2sTmwRRDyRxnr7bru3WzEzx2tnjvlRvOudta7oRc3e0R+uMZ+uNZ75xwq/MecC6Wz9XyM+ar4nQD+mg4xJrFLZSN/ZxHw5UVYmADNC/QdT6XXW1hr0rWHeuBrLBU6mjir2S9dv0u1lx60zyOZna3PbGHp3785vkehlJKKXXQiMgPRGRYRB7xPfYzEdng/NcrIhucx9eISMa37PL5G7lSSiml5oMGYuqoMZDI1KzIaHaqqCZzJdK5kvd4PJ13XmcvHldfvG4KBcgUSiSzRe/CdVd7mFLZsGFXnDWLW1jc2lQxb487X9JMeqrmznIlMgUioQCNwamP7PK2MKlccdq8S2DnQ2uuIyxy29TZbc7cQm22CrHqcMgf+J2zZhEitSrEcjO2S3TZipbKCrFAg3jH70DOHwbTj33vaJqe9giNwQZEhBUdzd6+upVitVomNjcGWdTS6D13zDmP6muZuHdziIUCDXS3RxiZyNMUbKjZDtF97KHdToXYHMe9XsvbwnYOsURmxnnJ/IFLzBd6AZy1ut372R+I+c+xvnh2WvDpHqMJZ16t1qoKMYCn9rTTFGxg0G3NGHfDqlkCsViYoVSWoWSOUEA4fUUb63ptRdgFJy4F4K4tI8TCQTqaQ9MCPO/vCWcbXe1h+hMZ+hMZ7zF3+w/usuHknHOIRdyqN1+FWDjIal/w6Q8C/c/fMTpJg+C1++x2qlehdtColKrPut4xHtgZ936/6u4d8ziauX32pse8uUKVUkqpI9QPgb/1P2CMeZ0x5gxjzBnAL4DrfYu3usuMMe8+hONUC8RQMss5n/0jW4Yn5nsoSiml5oEGYuqoMRDP1rwAHAw00BRsIJ0vzlEhVvnaSGMDOWcOMffiuBvSjE3m6WmP0N0e9tqUgb2IP9ccYkDFHGRgL3C3VVUMuUFHrSqxyVzJawU5m2g4SCo31TJxppCpur2i387RNEuiTV5o4Q91Vnc2sywaZldVhdieVI6l0dlb93W32wq4ctmQyhW84+b+eaAv5rc3hwiHGioqxFZ3TlWAreyIePuxyw0Ba7RMdMfmVoiNO4FYfRVi9tgFG2TWdpd+btvENZ0tNSvuljrniVshNlsotDe62yKk8yV6R9Mzzs21omruL38YfNaqDu/n1qapgMkf8NY6J/1z3/nn5GtuDBBw9n/lokhFi0DbtrCRpuDMx3RZrIl4usCu8TRLo2FWLWohV7TtG89f20koIEzmSxzjtCCcaplox+uGb+7xdQOoft8+uMHhgzvHCTbItHnXqnkhYcbOISYCLY1BjlnsC8TC09tsJrNFdoyl6XYCXbBB3XAqS6FU9s7xWoGuUmp2r7n87vkewl7JFksVv+8cTXPX1pF5Go1SSil14BljbgPGai0T2/7ktcBPD+mg1IL2u4cH2JPKcfXdvfM9FKWUUvNAAzF1VDDG0BfPzHjhvqUpSDpfIu0LxNw2hf3xLC2NgYpKDHBaJhYq27b5Q7OejgjLY2HvQnmpbJjMl2idJRBri9i5h6a1TMzUCMTaZg7E6q4QC4dIZYtM5orE04UZW6gFAw20NAa8i/9+O8fS3rxZUFnZ1N0eYeWiiFdR5RpO5eYMA7rbIxRKhpGJHKls0at+qQ4fDxR3niW30mfHaLoiEPNXiO0eT9PSGJix6mtFR8RrE+lWGtYzh5g/9Jut3aWfG4j5x+rX2hSktSnIUDJHY6Chrkq1enQ51YT5YnnmCrGqVof+sPRMXyAWDQdpbZrelrNvPD0t+JwKZ4tOGG1fJyJeILSyo9n57LktE7NzztflBoeP9CVYEm2qOJ7HLGnxwk+3OssfzIH9e8I/R2F3W5ixyTzZQtn7e8f9zO4et1V1gVlahkLlvGjufGkNDVJRoVbRMjEy1TKxdzRd0UKzqz1C2di7IXc78ykeqHBUqaPF5GFWaeVv7eh69pf+whu/d+88jEYppZSaF88ChowxT/oeO0ZEHhSRv4rIs2Z6oYhcIiLrRWT9nj17Dv5IlVJKKXVIaCCmjgrj6QK5YpmuGUKUSCjAZL7IpK9lolvZ0x/P0FVjbi03EJuoqBCbusBsK8QiXrs2t/JltpaJYIM0t7rIlcwUpwVy7kV2f0tG12TOziE2l1jYtkx01zFb1VU0HKpZIbZrPO2FMvZ5VYGYL0gCKJbKjE7OXSHW4xzLvnimogrPDQAOxvxH3W322MfTeRKZQkWgsKIjQsKp1Nk1lmFFR/OMoVWPM3+UMYZxZw6xeoIot8qpnvnDXG5Q468aqubOI7Y01lR30DYXf7g8c4WY/7yYCnEWtzaxclF1WOZUiDkBkxtiV7/P7vufyBRsC9Ia866t6IjQ1TYViA3MEoa73CBrx2iaZbEm75zubGkkFg5558KaxW4gVhngDSayLGmdmqPQH9i6n6vWpiAtTlBdT4Vj2GmTmsza884f/rnvd0XLRF+AtnN0klW+UM8dz0AiS994hmXR8ES/M8AAACAASURBVLT5FJVSs3tsIDnfQ9gr924fo0Ym5jHG1AzNlFJKqSPIG6isDhsAVhljzgQ+APxERGK1XmiM+a4x5mnGmKctWbLkEAxVKaWUUoeCXg1TR4WptoczVYgFSOcqK8TiaXduoNqtBMOhAJl8aVpY47X0cy7Kp3JFUtmCF4j5W5zV0t0eqQiQoHaFmHsBfyhZo2VivkhL09wVYtFwkIlc0dvebFVX0XBwWoWY235t5aLK4AOgKWirkVZ0RBhIZCiUbPu50ck8xsCSGaqKXO5YbCA2FQZMtUw88NUt3e1hBhIZekdtddfqikDM7mPfeIbd4+mKQKdaT0eEbKHM6GSe8XSeBpn7fQecVnyVc23NxWuZOEsg5rbXrDXH2L7yV1zNtF43zGoQaGkMVATHTcEAi1tt1Zx/n91zzK2uqg6O3Oe5IW7Md6yi4SDNjQEWtTTS1R5mKJmlVDYMJLJzVhQui00FtEujYV9F2FRLSvtnc8U43PEOJLMVoZt/e/4gfpnXUrG+9yIWDpLMFJ1Q3N+O1AnEKirE7Jh2jaUZTxe8scLU33398Qx98fRBCZSVOtJ99FePzPcQ9sqGXXF2VlVo+132u8c55sO/ZbjG9willFLqcCciQeCVwM/cx4wxOWPMqPPz/cBW4IT5GaE6GP7r149QLi/gG34W8NCUUupocdACMRH5kog8LiIbReSXItLuPL5GRDIissH573Lfa84WkYdFZIuIfF0OVCmDOuq5bfBmuije3BicViGWyLhza2VrBmmRxgBZp2Wi2+4NptomrmiPeBfCBxJZr/JltpaJMFVd5JfIFKYFKuGQbdk3UHMOsSLNdcwh1toUJJUt0O9Usc1eITYViGULJX587w5+fv9uyoaqQGyqpaGIsGJRM2UD20cmARhO5gDqmkMMYPueSQolM71CrL12i8D90dUWYTiV455towAVgYI739KusTS7xzMV1U/V/OHZeDpPWyRUc36vWqLhINGm+ivETlvRRjQcrJiTq5obns7U2nBfLI024e7SshmC5tamIO3NIaLhUMW8W9UtBKPhkLfPyWyBR/oS3LChH5heCeh+Dtzz3h8etkcaWbXIVu4tb4tQLBu2j0wykSvO2R5wWXRq+bJYEys6Ioj4grDFlcFja2MQkakKsYF4pmIb/vap/vDLDQ/rbfkZcyozbSg8ta/VwZz7XIAv3bwZgGMWt3rL3L+L+uNZW3l3gFuOKnUku3XzMGsuvYnHB1PzPZS9ctnvHp9x2e8fGeCK27YBeKGZMYYdo5OHZGxKKaXUIfAC4HFjzG73ARFZIiIB5+djgeOBbfM0PnUQPLgzzpPDE/M9jDnp1U6llJo/9Zch7L0/AB82xhRF5AvAh4H/cJZtNcacUeM13wHeCdwL/Bb4W+B3B3GM6ijhBkxdM1RlNDfaai+3Qqy5MUA8nSdXLDEykatdIRYMMJErMpkvVbUJDLN9ZJLFrU3ehf/+eMZrlThXy8TVnc0ks0Xu2TbKecd2AjYkqNVGb3mbnfOqP57hkb4EW/dM8sqzekjnS15rttlEnTnE+uMZAg0ya0gVi4TYuDvB1ffs4Jr7drKpf6p1lL9lYlOwgVBAvBDg/LWdNDcG+NivHuEn7zyP4ZQNMuYKxGLhEO3NIb516xZvrDB1/OqtsNkbPe0RjIGv3LKZ89d2ctzSqUDBDf2uXb+biVzRC8hqcavHekcnGU8X6Khj/jDXCUuje1W9s7qzhYc/8eJZn+O2TDyQgVgw0MDSaJjBZHbWyrMVHRGv2tL9nLjVZctjER7pS9o5xJxl163fzWduesx7/fG+98C/Dvcz7Q+j//3FJ5J3KhG7nDE9sGPc2ebs+97eHKIx0EC+VGZpNEw4FOCfLljLM9YuBuDCU7voi2d4ak8bAA0NQmtjkKQTEg8msjzjuMXe+pa1NSECwQZhccvUue4eq5nat1aLRkIks0WS2WJFiPWs45fwh0eHKir1wqEAH/m7k0hkChy3tJULTpxq7dLaFCQWDvLLB3fTH89y0WkaiC0kIvK3wP8AAeD7xpjLqpY3AVcBZwOjwOuMMb0iEgK+D5yF/U53lTHm84d08Ee4bKHE2/533XwP44D7+p+2eD+7Nypft343H/rFRn52yXmc63z/UEoppRY6EfkpcAGwWER2Ax83xlwJvJ7KdokAzwY+JSIFoAy82xgzdijHqw4+DZtq007ZSillHbRAzBhzi+/Xe4BXz/Z8EekCYsaYe5zfrwJejgZi6gDYMZomFKi8MO3X3BhkPJ1hMm8rxHraI8QzBW8OoloX0yONAUYm7Dxj/kDsGcctJtDQQEODeK8bTGS9Kpq52uG95uyV/PS+nVxy1Xp+8Z7zOXZJK6lscVrLRIDlsSb+/Pgw51/2Z++xeDpvK8TqmkMsRDpf4n/v3M7yWJjgLHMKvf0Zx/DpGx/lY796hLZIiCsuPptIKMCTwxOcs2aR9zwRobNlag6mFR3NfOblp/KBax/i63960quiWVpHOPPD/8/efYdJVV5/AP++2wvLArJ0cKkiICIiGkGxIGKJGo0tJjHGhPhTk2hiDPaKYu8NG1awl0jvvS2wLCwssCzLFrb3Nv39/TGFmZ0+c2fuzOz38zw8zNx6dpllZ+6555zbJmPBthJsLqq1JSJOPikNfTKS0cuPJJOvrAnTlIR4vHD96Q7ztnqmJWJ4VjpWHqgCAIwZ4LLVPABgWO9uSIgTKKhsQWO7Dj3TfI/1g1snBRi9e9bqp36ZnpOQ/uqXmWJpz+n+tTa2fybKGs3VB9bXsDWxY01qdktOQHycQHpSPA5WteDi0X3wrxmjcFJ6slNllzVxZp2zZ//zdPrgHg6xAcBrqw5bzuU5ASSEQJ/uyShr6LAlEP9z6Wjb+qyMZDxw2akO+1irJls0erRoDQ7/T5hbQiYjJTHOoTrQ+v+Ary0/zS0TzRVi3VMybMsnD+2Fpfec77T9rPOHuz3WiD7dkFvaiCkjeuO6iYN8Oj+FnuUu5bcAXAKgDMAOIcTPUsr9dpvdDqBBSjlCCHETgOcA3AjgegDJUsrThBBpAPYLIRZIKYvD+1VErw6dEfXtOrdVk1e8viHMEYXHfrt5aPM3F2NU3wzsLm0EABTWtDIhRkREUUNKebOb5X9ysew7AN+FOiYKj33lTRjYIxU905MgwCyYO0wQEhE5CmWFmL0/w65vM4ChQojdAJoBPCyl3ABgIMwXgqzKLMuIgnKsrg0Ltpdg2qgst23r0pPj0a4zoF1rgBDmi+mN7XrbLCn7loBWKYnxtraK9u0M/3LeMPzlvGEAzBU5QgDHmzS2pIG3hFhmWiLm3zYZ176zGf/6eg8+v/1s8zlcJMRuPTcb/TJTMKZ/d4wdmImnftmPrUV15goxH2aIXT1hAKpbNGjXGXH20F4etz1/VBaW33s+8sqaMKBHKrIsFV7nj3IeMPzBrZMcKsCunTgIGwtr8cbqw7Yqmqxu3pMzEwb3wAS7JAcA3D51KG6ePASh6Kg6qm8G0pLi8eQ1Y50ujgohsOLeaWjVGWAwSo8JuaSEOIzo0w0FFc2ob9P7Ne8sFF+XNTmkZIUYAJzaPwMJXlpBPnnNWNudaH27p+D568Zj+pi+AMxJnZ3HGpBuSd4O6pmGXulJeOuWiUhJdP36TYyPQ2pivK1lorsWpCP6dMOFp2ShTWfEmSf3xLgBmV6/nr7dU8wJsQzfvk8ZlnaG1lg6J++GnpSO5ETHJLOtQizT95aJxxs70NzhukrUHx/eehaMUqK3Dz97FFaTARRKKYsAQAixEMDVAOwTYlcDeNzy+FsAb1raSksA6ZYZGakAdDC/tyIf3TZ/O7YW1aN47hUAgHadAT/nHsdZQ3th//FmHKmJ/RaCi/IqsCivAjdPHux2m+ONHfhkczH+O3O0zy2AiYiIiELpyjc2YljvdKy+7wK1QyEioigSVEJMCLESQD8Xqx6SUv5k2eYhAAYAX1jWVQAYIqWsE0KcCeBHIcRYP887C8AsABgyZEig4VOMWrm/Cl9uL8G2ojpcMqYvyhs7kBAn8OTV49zuk5YUj3adEW06I9KTEtAzLQml9e04ZJkXMqpvhtM+qXYX7N0luRLj49AnI9k8X6i7tRrG+0Xtwb3ScP2ZgzBvfRHq2swzt1xViF1wSh9ccEof2/OpI3rjrTWFMEn4VCGW3Tsdc35zmtftrIQQDlU47owb6Jx8eOrqccgtacSGw7XomZaIpITARhgmxschMzU04w/7dk9B3mMz3FbKxcUJp1lu7pzavzu2HKmDEMBYD9Vk4XBq/+5IS4pXPI7Hfj0WBi8Di5MTHBNbN5x14oLrleMH4MrxA2zPf7jrXCQnxCPey8XWjJQEW8vE7m5+9lIS4/HxbZM9HqezvrbWkr4ljKwVYuUN5lg6t9F8+cbTEdcpwXnZaf1Q26p1+X+KK91TE9DUoUer1uD2a/WVP607KawGAii1e14G4Gx321haUTcBOAnm5NjVML+3SgNwL9v++GdrkfnblT17EXY/cgmeX1aABdtLvewVm6xf99FOScCimlZc8sp6GE0Sl53W3+lGFSIiIiK1FNXG/s1LRESkrKCuKkspp0spx7n4Y02G/QnAlQBukdJcIyCl1Eop6yyPdwI4AmAUgHIA9j2cBlmWuTrvPCnlJCnlpKws5+oU6tru+nIX9pY34eJT+2LJvkrsKG7Aw1ee6rFlWlpSAtq1BrTrDEhLikePtEQ0duhxqKoFvbu5bs+XmnTixyfDQ5LEOuerVWuuJnNX0dLZsKxuMJgk9llmdflyMfycYSfBmp/wZYZYOKUnJ+CN352BpIQ4W3VZJPLUNtIfo/tloLJZg+oWLXqmBVfZE6yhvdOx/8mZGNHHtySMr1IS473OxPNHWlKC12QYYE5EtVvam3r62fNX/8xUJCfE+dziMiMlAS1aPcoarQkxx0rSQT3TnP7f6ZORgn/POMWnr9N8jkTUtupgksp+rRQzJgMwAhgAYCiAf1sGxDsRQswSQuQIIXJqamrCGWPU2Ha0vssmw+x9sPGow/OLXloHo+XNhYnDJ4iIiIh8lj17ERblVagdBhER2QlZy0TLgPj7AUyTUrbbLc8CUC+lNFou2owEUCSlrBdCNAshzgGwDcAfAbwRqvgoNhmMJmgNJvz+7JPxz+kjUdWsQW5pI2ZYWrS5k54Uj3a9Ea1aI9KTE9AjNRFNHXocrGrBKf26udzHlwoxABiQmYKDVS1o1ZjbMfqaqBqWlQ4A2F3SAMB1hVhnE4f0RGK8gN4oPc51UsvYAZl455aJtgtrsWx0f3M1ltEkWZmjMPvEkJIJuVnnD8PFp/bxuR1YRkoiimrbUN7QgaT4OJ/agPrLPhHePTXyfqZJEeUA7HvVubohyLpNmaU9YiaAOgC/A7BUSqkHUC2E2ARgEoCizieRUs4DMA8AJk2aFPv/CQfgpeUH1Q4hYjRr9Lju7c04XN3qsJz5MCIiIooWGw/XYuLJPXzqnhNKH206iivG9wcASPDNFBGR2kLTd8zsTQAZAFYIIXKFEO9alp8PIE8IkQtzq5877Nr73AngAwCFMFeOLQlhfBSDdEYTANjm9vTtnoJLx/bzOpcpNSkBUgL1bVqkJcUjMy0JUgL7jzdjpJuqmhQfE2L9M1NR2aRBs8aAbskJPs+IGt7bnIjLtQy5z/Shyig1Kd7WyigSE2IAcPGpfTFjrKtOq7Hl1H4nXje+VhyRb6w/b/FxAmkKVkL27Z6Cc4f39iuOFo0B5Y0d6N8jJSRzdeznhrFCLGbtADBSCDFUCJEE4CYAP3fa5mcAt1oe/xbAakvlfQmAiwBACJEO4BwABWGJOgZ1Tv50ZeMfX+7y+3HdO5vx2ZbisMdDRERE5I+Sunb8/sNtuP/bPLVDcUmAM1mJiNQSsivmUsoRbpZ/B+A7N+tyALgf9ETkhc5gSYj5OZ8qPdl8Ub2mRYseqUnoYbkIbTBJnNLPl4SY+wvVA3qkoF1nRHljBzL8SFJlpiXipPQk5JdbWyb6djH8nGEnYUdxg6KJAvJfVkYyTkpPQl2bTvWWibHG+rPgT4I5FDJSEtGi0aOsod1pfphy57CrEGNCLCZZZoLdDWAZgHgAH0kp84UQTwLIkVL+DOBDAJ8JIQoB1MOcNAOAtwB8LITIByAAfCyljMxP/RQzHvkpH3/4VbbaYRARERG51ao1AAAKq1tRWm/+vKbmZ0crVtsTEakvlBViRGGntSXE/EsGWUvoa1q0SEs2zxCzGtU3uJaJ/TJTAACHq1r8rvAY2jvdVvXmS8tEALhwdB/ECYTsAj35RgiB0f3NydQerBBTlPXnTcl2iYHGoTdKFNW0YaCHGYXBsE+Cefp/hqKblHKxlHKUlHK4lHKOZdmjlmQYpJQaKeX1UsoRUsrJUsoiy/JWy/KxUsoxUsoX1Pw6iIiIiIgiSUFlC857fg3mby5WOxQHauTm8o83Y9LTK9BmSRbGsl/yjtu6LRERdcaEGMUUrd6cPEryt0LMUk3V0K5HelKCQ0JsZF/XFWKpln0S44XHirT+meYL5cfq29HNzwva1jli/rSGmzikJ/Y8NgMj3LR6pPAZ3c88R6wXZ4gpypoYUjtBZJ3v1dShx8AeaaE5h10ivLuPSXEi8k1Dm07tEKLWsbo2tUOgGLerpAHZsxfZZukSEREFI+dYZP0+0RtNuPvLXSiuDe97qtpWHQojrE243mjCjuJ67xv64e4vd+OatzYpekwiih1MiFFM0RqMAPxvmZhql2xKS4q3VfT0z0xx26bMWiGWkZLosfR+QA9zhZiU/le0DMsyV6dlpno+R2ecNRQZzh+VhayMZAwIUfVQV9Ut2fz6VjshZv9zNjAMLRPV/nqJYs3lr29QO4SoNe2FtfjLJzsg2feHQmTtwRoAwLpDNSpHQkREpLxtRfX4Ja8CD/+4T+1QVPf80gJc/+4W7CtvCsv5JPj+lairY0KMYoo24BliCQ6PrTPERrmpDgNOzBDzdpG6T0YK4uPMySy/K8R6myvEfG2XSJFl2qgs7Hhouuqt/WLNiQoxdX8u7H/2Q9WilC0TiZR3uKoF2bMXoaJJE5bzefv/If+JS9EnIzkssShp5YFqfJNThoXbS9QOhYiIiMhBVbP393n+pEU+2VyMO7/YGXhA5FZBZQsAoC7E3RvUnyBHRJGCCTGKKbaEWKK/M8QcK8QyUxORECcwup+nhJj5x8fbRer4OGG70NXd75aJ3QLajyiWRUzLRLtEdchmiFnOkZwQ5/dsRCJybVcYW7ANyEzBzZOHAABG9HGeSbr1gYsdbsqJNvd/l4fZ3+9VOwwiIiIim8Z2PW6bv8Pten+671g99nM+Fu+tDCYsIiKKENH7CZzIBWvLxKR4/3K9aUmOFWIJ8XGYf9tknNrffULM2mYxI9l7lUr/zBRUNGn8rhQa0isN8XGCs4OI7Fgrw9SuvLMm5OIE0C8zJSTnSE+KR5zg/DCiQJhMEkI4X/RYll8VlvP/dNcUDOmVhvTkBHRLTsAtZw9BSX07LnppHQBgyT/Ps/3fMX5QJlYeqA5LXKHw7OID+O2Zg9zOXSUKFLtyEhGRv7YfrVM7BCIiimCsEKOYcqJCzM+WiZ0qxABg6sjeOKmb+xZGqT62TASA/pbqkW4+JM/sJSXE4ZS+GSGrPiGKRt0jpmWi+fz9M1OR6GcS3ldCCGSkJKpeDUcUjYY9uBgP/uA8l2F1gfKJp89un+zw/NUbJ+D0wT3QMz0JSQlxuPXcbCTEx6F/pvn3+eTsXji1f3fb9g9cfioAYNzA7nBlxpi+isespPfWF+GSV9arHQbFELY1IiKiQH2xje2ciYjIPV5ho5ii1Qc2QyzNfoZYkm8/FicSYt4vyg+w3AEeyEXtT2+f7PfXQxTLrD9zaieJrOcPdcK6e2qCwywxIvLdgu0lePba0wAApfXtWLpP+VY3r944AeeNzELx3CuwqbAWR2vbcM0ZA11um5oUj69mnYPR/R0TX8N6p+PBy0fjyvEDkJWRjJEPLXFYP++Pk5A9e5HisSvtwhfX4uUbTseYAd3Z5pWIiIiIVCWlDKhFJhHFNibEKKbojNaEmH8XYVLtZo6lJfu2b0qS7xVi/Sx3hHcL4AJ+bw9VakRdUaTMEOuWlAAhgIE9Q5sQ65WWhF7pSSE9B1Gsyy1txDVvbVL0mH+bNgwDe6Ti6gkDbMumjOiNKSN6e9zv7GEnOS0TQmDW+cNtz1+9cQLadAY8ZFfh9pepQ/HBxqMO+00d0RsbC2sD/RIUd7S2Db95ezMAYOW/pmFZfiXuvGA4L0QQERFRSEXyWw370NgJOLzyyppw+uAeaodBRBGGCTGKKVq9eYaYvxVV8XECKYlx0OhNflWICQFk+jDbx1YhpvLMI6JYMKRXGv7vguGYfqq6LcTi4gSmjcrC+aM8X/wO1rPXjve7DSwROVI6GZaZmoj7Lx2N+LjQXH2xVpjZJ8QevnIM7rxwBCY+tcK2bGTfbhGVELN307ytqG3V4uoJAzCoZ5ra4VCU4oVDIiKKSRGcwIsl1pvmiYjs8QobxRTbDLEAWgxaE2FpSb5ViCXGx+GdWybid2cP8brt2AGZSE+Kx/A+3fyOi4gcxcUJ/HfmaAyIgNl682+bjN+cMSik5xgzoDuGZ/H/DqLOLn9tA95YdTis53z0yjEAgEX/mBqyZJgnnatFI7ktYW2rVu0QKIpF8p3+RERE0Yw3mxBRV8eEGMWUEwkx/y8QpVoSYel+VHHNHNcffbuneN1uyElpyH9yJkb1zfA7LiIiInK2v6IZL6045HW70vp2Rc6374lL8eepQ1E894qwVTy9+/sz8dsz3Sfd/3RudljiCIYQAgcrW3D3l7tg8OMu3WaNHoXVLSGMjIiIiKhruuy1DZj9XZ5f+yzZW4Hs2YtQ1awJUVREROHBhBjFFJ01IRZAezF/K8SIiIhIfTqDCUU1rW7Xn/f8mqDPUTjnMnRToe3xzHH98OL1p7tdnxh/oozm5RtOx4b7LwxHWH75cMNR/Onj7fglrwIjHlqC/3yzx6f9bnh3C6a/vD7E0REREVGXEGllUSrHc6CiGQt3lPq1z5fbSwAAByt5wxIRRTcmxCimaA3mGWJJ8f6/tNOS/a8QIyIiInU9/ONeXPTSOjS06bCpsBZrDlYrevy/TB2KhADeV4TbtRMHYXCvyJvV9dGmo6hoOnEn8Tc7y9DQpgNgrgK75q1NOFrb5rRfAS+2EADISLuCSUREpBy2CCYiCj9e+aeYojWYkBQfh7gA5nqkBdAykYiIiNS1qbAOANCqNeCWD7YBAIrnXqHIsZU6jpJyH70ED3y/F0v2VdraPUebN1YXIiFeIDM1EbmljfjbZzlYfu80tcOiCCLAK4RERBR7JG/0ICJSHa/8U0zR6k1ISgjsLu40S8vE1MTovLhERETUFTRr9Oiekhjy80Ri+0EA6JGWhNdvPgMN7Trbe5do89GmowCASSf3BAAcqnLf8pKIiIjIH5F2S4XLFJglSObHiIjCL/L7vxD5QWswIjnAhFh6UjxSE+MRH0B1GREREYXe4aoWjH98Ob7OcZ55oHTLmUhsP2iVGB+HPhkpAIB7po/EsN7ptnWTs3sBAJ68eqwqsfkj51iDw/Mfd5ejqUOvUjRERBSNhBAfCSGqhRD77JY9LoQoF0LkWv5cbrfuASFEoRDioBDiUnWipq7O+rZ157EG3PDuFugMJlXjeXttIT7YUKRqDERE4cKEGMUUncEUcEKsT/cU9OmerHBEREREpBRrJdFauzlh1tYzeuOJW2wXWoZ+B2LqiN7Y8sBFAe8fbvdMH4XV911gez6ghzlRNrBHKtb/50SV2zUTBoQ7NL8UVDbjnq9ycd83exyWbyqsxWWvbcC7645g3aEalaIjtfDGeSLywXwAM10sf0VKOcHyZzEACCHGALgJwFjLPm8LIdgihnz2r69zg9q/8++1Dr0R24vrUVLvPE81nJ5fehBPLzqgagyhwNvdicgVJsQopmgNJiQH2PLw7xeNwIK/nqNwRERERKQ0+/Yy1oe1rVrbstnf7/X7mGvvuwAXje6Dl284Hf0zU4OMUD1PXDUO904fhQtP6YMhJ52ocrvxrCEqRuXde+vMdyWXN3Q4LL/lg204UNGMuUsKcOtH29UIjVSgdMUnEcUuKeV6APU+bn41gIVSSq2U8iiAQgCTQxYcRQ2D0YQOndHrdt/vKlfkfIK/6IiIVBOdgweI3NAajEiKDyzPm5GSiIwwzCQhIiKiwLi6dhDs7IVnfnMabjprMOLiBD7601nBHSwCZKYl4p/TR9qeP3fdaRjVNwNnDOmpYlTe/bDbfIFpf0WzypEQEVGMuFsI8UcAOQD+LaVsADAQwFa7bcosyyiKVTdrgn4/+NdPc7DmYA2K517h8z5VzRr07Z7idbtAU1+tWgPqW3UONzgREVHwWCFGMcVcIcaXNRERUSyzv+hhMJmf1LZo3WztWa/0JMTF8PzQG88aYkuG9clIRt8oaA8dbDsiIiLq8t4BMBzABAAVAF7y9wBCiFlCiBwhRE5NDVv2RrLJz6zC3vIm23Nfq6/s30+uOejfv/HOYw04+5lV+H5XmV/7+ePG97bg/BfWKH5cGWz2UEHtOgM2HK5VOwwi6mKYOaCYEswMMSIiIops1ssb0m4Cg7VV4iM/5Qd0zBlj+gYbVtTY/tB0bH3gYmyafRGevmac2uG45akdUYtGD5PJ/YWcQ1UtKKxuDUVYpIIIumZHRFFESlklpTRKKU0A3seJtojlAAbbbTrIsszVMeZJKSdJKSdlZWWFNmBSlLeET7DdCjV6Iw5WtgAAdhQ7duuUUmLLkbrgTmCRf9y5aj579iLc9cUuRY4fCV5afkjtEIioC2LmgGKK1mBCcgJn4hIREcUi6wWMZflVTuvsZ4j5I5arw1wRQmBgj1T8/pyTMXZAd4d1SVFwilc5pAAAIABJREFUU9Fpjy/Ha6sOu10/45X1mP7yujBGRKHQtX4qiUhpQoj+dk9/A2Cf5fHPAG4SQiQLIYYCGAmAAyrJQVlDO6bMXY3yxg6X60c/stShIs3el9tLcPP7W12usxdMldaivRUB7xuMUNyk0qY1KH9QHxyra4uoSjkiCq/I/9RL5AetwcgKMSIiIiIfPHHVWIfnOx6arlIk/llsuRAkpUSHzqhyNEREpCYhxAIAWwCcIoQoE0LcDuB5IcReIUQegAsB3AsAUsp8AF8D2A9gKYC7pJT8RdIFHK5u8XnbhdtLUd7Yge93um+HuCy/0uXyY3XtfsfmTV5ZI258bwu0hsh4qfpaYbd0XyVaVUp4eZJf3oxpL6zFhxuPqh0KEakkZJkDIcTjQohyIUSu5c/lduseEEIUCiEOCiEutVs+07KsUAgxO1SxUezS6k1RcXczERERBYJ1I0qalN3L4XlmaqJKkfjHaGmZ+PKKQzj10aVo0eidtll3iPNeYoF9e1QiIleklDdLKftLKROllIOklB9KKf8gpTxNSjleSnmVlLLCbvs5UsrhUspTpJRL1IydwudQlet2ypsKa/HbdzYHdWy90RTSZNUD3+/FtqP1OOzmawilvWVNAVVSFVa34I7Pd+L+b/eEIKrglNSbk5Y5xQ0qR0JEagl15uAVKeUEy5/FACCEGAPgJgBjAcwE8LYQIl4IEQ/gLQCXARgD4GbLtkQ+0xk5Q4yIiIi8++/M0fjkz5O9b0gRp6i2DQDw7rojAIDGdnNC7Lhda6OHf9wb/sBIMcHOdyEiIvLFv77ORc4x/xMj9W062+OLXlqLUx5eqkg8NS1aLN2nTkvEzjYcrsGv39yIT7cc83vfdksFf2m967aT4cL3E0TkSoIK57wawEIppRbAUSFEIU4MOC2UUhYBgBBioWXb/SrESFFKq+cMMSIiolil1IfaPY/NiJpqqFAreGomth2tx46jjkPh/3nxSCTECby0InKHneuN5juW88qaMLhXGi59Zb3D+hX7q3DmyT3RKz3J7TGqWzRIjItDTw/bdPb1jlJMyu6JYVndAgucvOJYDyIiCoeq5sBm0NrzJ+nj6ffboaoWzLC8l9n3hK2Zlmrtoa2VVAWVvrebjEQ6gyngWcNEFJtCnRC7WwjxRwA5AP4tpWwAMBCA/YTJMssyACjttPxsVwcVQswCMAsAhgwZonTMFMW0BiOSE1khRkRERO4xGXZCSmI8po3KwrRRWQCAc4efhF7pSbj3klEAgBatAfPWF6kZokv27Xvu+nIX6tvGosVuTkVpfQf++mkOeqUn4bFfj8HVEwa6Ogwmz1kFACiee4XP577/uzykJ8Uj/8mZAUZPvhJsk0pERBaHqlqQFB+H7N7pihzvWH3w8772H29WIBKznXaVatb20MCJyvimDucW0eTdgz/sxbc7y9AtWY2aECKKREFlDoQQK4UQ+1z8uRrAOwCGA5gAoALASwrECwCQUs6TUk6SUk7KyspS6rAUA7QGtkwkIiKKVbw0Hnpf/vUcvPm7ibbn904fpWI07g19YLHD80d+yne5XX2bDv9cmAuN3hjQDAx32lS6W7ur4QwxIiKymvHKelzw4lrFjrfezbzRzr97qls0bo+xp6wpoHMfqPC/6uqPH223PS6obEb27EU4VBXd1VvhsLqgGgDQanfjFBF1bUFlDqSU06WU41z8+UlKWSWlNEopTQDex4m2iOUABtsdZpBlmbvlRD7TGkxIYkKMiIgoJgkFeib2656iQCRdR6zMXhj9yFLc8N4WtcMgH8XK646IiKLL4aoWvLXGPKPU+rvIWk2upOeWFvi9j33V2KI885yxpfsq/T6Ofbrv0y3FaGrvmpVnvOkmskgp8c7aIw7z+YhCJWSZAyFEf7unvwGwz/L4ZwA3CSGShRBDAYwEsB3ADgAjhRBDhRBJAG6ybEvkE4PRBKNJcoYYERFRjPrrpzlBH+Pnu6coEAlFox3FDShrONEe6bznV6sYDREREUWaHcUN3jfyUyhv8gi2+P3Rn/Lxn2/3KBNMlOBNN5FpR3EDnltagP9+l6d2KNQFhLKU5nkhxF4hRB6ACwHcCwBSynwAXwPYD2ApgLsslWQGAHcDWAbgAICvLdsS+URnNAEAWyYSERGRk3umj8Tzvx2PPqwQ80t8nPNVg7suHK5CJMqY+twavLfuCBradCit71A7HCIiIlKYmnU/SrZn9kTJnE6jj7PJIrmi6r/f5mHKXN7oFM30lmu6bWxtSWEQsomCUso/eFg3B8AcF8sXA1jsvAeRd1o9E2JERETk7Lv/+xXOPLmX2mFEpcT4ODx9zTgs2F6CfMvg+NH9uqNwzmUY8dASlaMLzLNLCvDsEt9aFUkp0dxhQGZaYoijIlfCdF2RiIhiSEWT+5lfFDjr72Rhl47beawB172zGev/cyGGnJSmUmTAVzmlqp2biKIPMwcUM7QGc0IsiS0TiYiIyA6TYcH5/TknY9E/zsMVp5k7ogsBJMTH1seIulYtAEBnMOGRH/fZnr+/oQinP7kc5Y3marJw3fnd1SkxL5CIiKLbdzvLUNUc/cktX986WCtk/Dq2ClVb9r+iv7EkojYdqXW5bSRXlXW281gDZryyDh06o9qhEFGIxdYnWerSdAZWiBEREZGjXulJaocQM07qZv5epieHrMmEajr05osfS/ZV4LOtx/D0ogMAgBX7qwAAZfXm2WPMhxEREYVeU7se//5mD279aLtqMQghsNlNoscd6w00gaj0p7Itwm8cEYo2dQyG73E8vWg/DlW1Yn9FcwjjoUAZTRJGE9+IkzKYOaCYoTWYL2QkJ/JlTURERGaPXzVW7RBixgOXnYpnrz0NF4zKAgCsue8CnHlyT5WjUoa1Isma8DKaJJbuq0SLxjzHwPr5mx/DiYiIQs9gMt/wXN2iVTWOLUfq/Np+8d5Kt+vWFFQHG44T3qgTOH7vwk+jD7z6bsyjSzH1Oc6JI2Uwc0AxQ2urEGPLRCIiIgL+Nm2Yrc0fBS81KR43Tx5iSx4N7Z2O7/7vXBx4cqbKkQVvytzVaGjT2W64Lm1oxx2f70RBZQsAc6tEncGEhnadilF2PbxWRUREseK2+Ts8rpdunziLlPqraBQ51Wtdy/pDNRj9yFLsKK53ud5bglJrMHE+ICmGCTGKGbYKMbZMJCIiIpgrmuLj+KE31FKT4nGy3SD1/84crWI0gbvm7U34Ja8CALC7pNFhXWlDO0Y9vASP/rRPjdCIiIgoDCJl5tXaQ75Vk0VGtETeWefM5RQ3eNwuwruBUoxg5oBihlZvrhBLYkKMiIiIKKysd3Wuve8C/N8Fw3HdxEG2dedbWixGumN17baZYZ0VVrcCcG6FdNvH2zF5zsqQx9ZVvbP2CPaWNakdBhERxZBouN7+z4W5HtczaUBEFDhmDihmaI3Wlol8WRMREXV16/9zodohdEnWCzSZqYm2Zf+4aIRK0SinXed65sGagzWKzzc53tih6PGi3S97j6sdAhERdREP/aB8JXhTh17xY9pEySCs7NmLcPeXu9QOI+oV1bSiqpltA4mCxcwBxQxrhRhniBEREXVtqYnxGGLXwo9C75Erx6B3tyT07Z4CALjv0lH4z6WnYN8Tl2JSdi+VowveF9tKwnKeVQeqcO7c1Vh1wHWlGhEREQUmr6wRS/dVet9QYYctVeZKCu8cLGWSbta21GqL5uq6i15ah7OfWaV2GERRjwkxihm2GWKJfFkTERF1ZQeemql2CF3OJWP6IufhS5CSaL4xKS0pAXddOALdkhNUjix0jKYTF4j2H29GuQKVXXss7QH3lnftNoHRfLGKiIiUI11UQO08Vm+7/uOPq97chDs+36lEWH7708fbvW4TyK++11cXOrwfUZKnpJvBaMI+H96r7CtvRmO7TsmwFBMdtXVEFArMHFDM0BosM8Ti+bImIiKKNesP1agdApGD4Q8utj2+/PUNmDJ3NZ5ZfMBpu2aNHiYfL1ZZK8Ma2iLz4hEREZHarntnC57+xfn3bSRbe9D7+1h/bgax31aN98jPLzuIK9/YaKt+89S5cVNhXZiicubP9zRKuk/GPP47hF6Hzoi31hTCYBk91BUxc0AxQ2dJiLFCjIiIKPZsKfLtw/Tex2eEOBIi9+atL8IvecexcHsJpJRo6tBj/OPL8cLygz7tn3+8GQBwoLIllGFGlfC2hSIionD6cXc51hysdrteuMloHOTvSZtQVYh1Zp+oyCtrBADUtbqeo+otEWUyybDF7S9WqQdHozfixWUHodH7X8VJ4fHqqkN4YdlBfLerTO1QVMPMAcUMa4UYZ4gRERF1XRkpiWqHQF787+6ptsfL7z1fxUhC4+4vd2P293vx2dZjtjZB3+4sw5xF+1Hd4uMg9Mi8RkRERKSoe77KxW0f7/B7v4YwteGL1NzIfssNNIrw8z2HEt+TG97b4lBpH0laNQa1Q4hqn2wuxptrCvH++qKA9o+UhKTJJPG797d6TNhHq3atOVlpvY7eFTEhRjHDNkMsgS9rIiKiWFPZ5GMigSLa+3+chNMGZdqej+qbgcI5l6kYUeiU1rfb7qauadHi/Q1HMXnOKhyu4l3t3rAqjIiIPLG26gvEsvwqn7aLlAvzrizNr1Q7hKDkHGtQOwQnJsubtts/8T9BC5iTlK5m3nU11iSLLsrb8WkMRmw+Uoc7P9+ldigUAswcUMzQ6q0VYnxZExFR9BBCzBRCHBRCFAohZrtYnyyE+MqyfpsQIttu3XghxBYhRL4QYq8QIiWcsYfTD7vLvW5z+9ShYYiEArH1gYux65FLcMmYvk7r3LVDinYmCdS1ObcSuuSV9V731Rgc28w8/nM+vth2TLHYiIiI1HZIpRtENhbW+rRdV745w2SSis0mm7/5qCLHCTVrQkxv9D+pteVIHS5/fQM+2VyscFSxR7INAkUAZg4oZuiMJiTFx8XsRRUiIoo9Qoh4AG8BuAzAGAA3CyHGdNrsdgANUsoRAF4B8Jxl3wQAnwO4Q0o5FsAFAPRhCj0iPXj5qWqHQG70y0xBr/Qkl+viYvSt24cbj+K6d7YEtG9eWRM2212wm7+5GA/9sA8AIKWEPsrvuiUiIprhww0ialqWXxkVl+6bOpR/+//RpqOKVaHtKI68ajDAcSZasErq2wAA+ysUbGUZ5Y7WtjnMEevKCWaKPEyIUczQ6k2sDiMiomgzGUChlLJISqkDsBDA1Z22uRrAJ5bH3wK4WJjv/pgBIE9KuQcApJR1UsouO724f2YK4mM1sxLjhBDYcP+FtufFc69QMZrI8VVOqcvlt3ywDSMfWoJmTdfIf/NeNyLyRAjxkRCiWgixz27ZC0KIAiFEnhDiByFED8vybCFEhxAi1/LnXfUiJ1e0BiPatJExwym3tFHtEHzy72/2KH7M0vp2xY/pysIdrt/rdKY1KPcRh+8rwuOXvAr86+tctcMgconZA4oZWoMRyYl8SRMRUVQZCMD+k2CZZZnLbaSUBgBNAE4CMAqAFEIsE0LsEkLcH4Z4I9ba/1ygdggUhMG90vDIlWPwq2EnqR1KWJhMEl/vKMWjP+1D9uxF+GRzMQydqr5cXa+pb9Nh85E6AEBj24mEWEObDuWNHaEMOax4sYqI/DAfwMxOy1YAGCelHA/gEIAH7NYdkVJOsPy5I0wxko+uemMTxj62zPZc7ZlM7brYu9es87d0e3G9x+33V7SEZZbvhxuPInv2IqeE6I+7y3HKw0tRVBP43LhAFFa3dJmbj0Jl42Hf2pMShRuzBxQztAYTkhPi1Q6DiIgoXBIATAVwi+Xv3wghLna1oRBilhAiRwiRU1OjzDyAcGpq9/5hlO8BoourhMftU4diwaxzAACP/fpE59BhWel4/4+TwhVaWHy7swz3f5eHT7eY54I99nM+bn5/q9f9fme3jf0MhqnPrcaUuauVDzQC7IzQVktEFBmklOsB1HdattxyExEAbAUwKOyBUUAOWuaKRcoojNhsUexfknFPaSPOeXaVAkfyzDqzrL5NBwB44n/5mDJ3NZbuM7duPFjp/8w5X19FF764FvvKHdsdTn95PW54N7DW1+Q/zhajcGJCjGKGOSHGlzQREUWVcgCD7Z4PsixzuY1lblgmgDqYq8nWSylrpZTtABYDmOjqJFLKeVLKSVLKSVlZWQp/CaF3+pPL1Q6BFLbi3ml48frT3a6/bcpQ2+MHLzsVF43uE46wwmbR3gqnZZ1nbAghkFvaiM1HTtxdW2B3MeiLbSXYV96Er3NK0RaDd7BbebtznYjIiz8DWGL3fKgQYrcQYp0Q4jy1giJH//02DzuPnfj/Xu3KsGhlMJqwq6Tz+wlljm2fsAjHPKiPNxWHpPp9xf4qp2VHa9tcbmv/vmvnsQZ846adNSmHs8YoHBLUDoBIKTqDEUlMiBERUXTZAWCkEGIozImvmwD8rtM2PwO4FcAWAL8FsFpKKYUQywDcL4RIA6ADMA3AK2GLnCgII/p0w4g+3XzatndGstN8uLEDuiP/ePQOLl93yHulptZgxDVvbXK7vqimDVe+sVHJsIiIYooQ4iEABgBfWBZVABgipawTQpwJ4EchxFgppdMvFCHELACzAGDIkCHhCrnL+iqnFD/mnrgn7OEfzSPhIqVSLFq8tuow3lhdiH7dU/D4VWMwc1z/gI7j8fvuwz9JJP+z6Y2BJVuve2czAOD6SYO9bOkfo0lCAIgL0yzkL7eVYEivNEwd2Tvk52rWGNCqNaBbMtMPFFmYPaCYwQoxIiKKNpZ2PncDWAbgAICvpZT5QognhRBXWTb7EMBJQohCAP8CMNuybwOAl2FOquUC2CWlXBTuryES3DYlW+0QKIQmDO7htKx/ZooKkYTX4r2VHtevPOB8hzMREZkJIf4E4EoAt0hLuZGUUiulrLM83gngCMwzWZ1Ee3V9tFuyz/PvwHAJV17n/m/zUN8W/LyqAxXmiqbKZg3u+HxX0Mez56lor3O7u2N17YqeOzQiowpx+IOL8X9f7Azb+R78YS9+/+G2kBy7XWdAh96xa8E9C3NDci6iYDBFSzFDq+cMMSIiij5SysUwtzu0X/ao3WMNgOvd7Ps5gM9DGmAUOKVvhtohUAh8e8evMKBHqu15SmIcNHrzLI+5143H/E3FKG1ox0+5xwGY70bu6h2Wvt5RigU7SvDDnVN82r6uVYuTuiWHOCoiovASQswEcD+AaZa20tblWQDqpZRGIcQwACMBFKkUJvnAJCWklDFfKbarpBG7ShqDOsYtH2zFpsI6hSJyz76lnfXRkWrHloP/WLDb5b6L8iowuFeqy3VWR2paMbhXWlAxRptl+bFxk9OYR5c5LTtc7f/sN0+MJunUOYIiT5vWgDOfXoG3b5mIi0b3VTscJyynoZjRotUjLZkJMSIioq7ktZsm4AaFW5dQZJiU3cshIVbw1GW2x727JeO+S0/BtRMHAQC+v/NcHH32irDHGGnu/y4Pu328oPbj7nKc+fRK5JYGdwEuFOpatWqHQERRQgixAOa20qcIIcqEELcDeBNABoAVQohcIcS7ls3PB5AnhMgF8C2AO6SUHFQYwRrb9Xjwh32qnX9VQbVq5/bHZ1uKw5IMc+ejTUd92u6uL3fhqjfdt4MGgD99vMPheefqM6VsP1qPd9cdUfSYXeHGrA82FCF79iI0a4KvaHTF2793fZsuJOclRyMfWox56wP/+SiqaYNGb8LLKw4pGJVyQpYQE0J8ZXnjkSuEKLa84YAQIlsI0WG37l27fc4UQuwVQhQKIV4XsX4LCCnGaJIorG7F8CzfZlEQERGROm77eDuyZyvX2fHqCQPD1nOfIs+0UVk4+PRMTBzSU+1QIopGb4TJ5PmCwuYjtQCAZfmR0ZbK3vsbHC+s7S1rUikSIop0UsqbpZT9pZSJUspBUsoPpZQjpJSDpZQTLH/usGz7nZRyrGXZRCnl/9SOn7xbsL1E0feO/ihr6PB529Med66OCZdHfspX7dzhovQV4maNAXOXFChyLBG25ppmhQpWXdW36VDT4vuNSF9sKwEA1Pqxjz13ScNQfg/1RhN0BlPIjh+L9EaJZxYr8/MRiUKWEJNS3mh98wHgOwDf260+0vmNicU7AP4Kc9n6SAAzQxUfxZZjdebM8+h+bJlEREQUydYcrPFre94FSN6wZbaz0Y8sxS0fbMPkOSvxips7M60XHt5ZewQHK5VtZ6O0X7+5Ue0QiIgoxLRRfsG6RWNQOwSKMQu2l+Cehc7tJ697Z4ti55j41AqcNWelYsdzx1tCM1SVgAAw/eV1GPXwkpAdP5wMRhN+yTsOGUQ5Yii/19Ei5C0TLVVeNwBY4GW7/gC6Sym3WgaefgrgmlDHR7GhwPIhfnS/7ipHQkREREqa+NQKt+tW/XtaGCOhSHHV6QPcrlt6z3nolswxyQCwpagO1S1avLbqMI7WtmHlfvN8ih92lyF79iJUNGts25Y3trs7DBEREcUQJdv68bJ6aD3w/V78aJmVa0+jNyp+rmASLEoKRaXYsbrYeZ87b0MR7v5yN/6XVxH0scJR17ivvBmfbT0WhjP5JxwzxM4DUCWlPGy3bKgQYrcQYp0Q4jzLsoEAyuy2KbMsI/KqoLIFcQIY2ZctE4mIiLqC9KR4tkrugvY8OgMv3XC62/Wj+3XHtRNdf4RYes95uLGLzpu78MW1+MunOTjzqRV4+pcDAID1h05Ua/55fo5tbtfByhY0tZvnQtz7VS7mLNrv0zmklNAalL9AQ0RERMrxlPbQ6I2obtF4reZxtb42Aud/KjWJ5601hYocJ5LNXVoQ1MyoaJE9exGe+sW397aRqKrJfENbvQI/b+FKgX66uThMZ/JdUAkxIcRKIcQ+F3+uttvsZjhWh1UAGCKlPAPAvwB8KYTwq6xHCDFLCJEjhMipqfGv7Q7FpoKKZmT3TkdKIlvmEBERdQVtOl5474oy0xKRGO/5I8zDV4zBD3eea3t++9ShOG9kb4zu1x3PXHtaqEOMaHVtOtS5aUO681gDCiqbcemr63HtO5vQ1K7HD7vLneZ5ufPG6kKc8vDSkA1ZJyIiouD9uLvc7bq/fpqDyXNWBXRc+wIjped9BUOJ9usvLDuoQCSR7b11RXhmcQEMxuhuXeqLDzf69t42VoV75l0kCqqfiJRyuqf1QogEANcCONNuHy0AreXxTiHEEQCjAJQDGGS3+yDLMlfnnQdgHgBMmjQpMmo6SVUHq1owbkCm2mEQERFRmPz9ohFqh0ARKikhDmcM6Wl7/siVY2yP4+P4AdCdqhYtZn22EwBwpKYNpz+53LauXWdAWpLnj47f7jQ3+2ho06F7SmLoAiUiIqKA7S5pdLtuw+HaMEbins5unlwwnfyKaloViKZrKahsQWF1K645w7embSV17fho01E8avd+216EdGJ0YjCa8NGmo/jjr7JZXNEFhbpl4nQABVJKWytEIUSWECLe8ngYgJEAiqSUFQCahRDnWOaO/RHATyGOj0Jsa1EdNhWG9hdqm9aAY3XtOKVfRkjPQ0RERJHjb9OGqx0CRambJ3fNtonePPLjPrfr8sqaAABVzRpkz16Ea97a5HZbTxc+2nUGNHV4riDTd4E7k4mIupqmdj2qWzTeN6SQ21/RHPJzBFuB8vqqwy6W+n/MiqbYf83pjSbMXVKgWIX+lW9sxD1f5fq8/Z1f7sT8zcVheV0p6ftd5XhmcQHeWO3qtUaxLtQJsZvg2C4RAM4HkCeEyAXwLYA7pJT1lnV3AvgAQCGAIwCWhDg+CrHXVx3GKysOhfQch6paAIAJMSIioi4kjXfykRf3zRiF26ZkOy1/9trxtsfu7mYlZ+WNHTj7GXMbpdxS57vLfWmPdP7za3H6E8s9bvO/Pc7D44mIKLqd9cxKh1Z8/1iwW8VoyBtXCS3r/S61rVpsPlLnYr1ypUBvRvjMrpvmbcGEJz2/nwmXH3eX4911R/BimNo6yk53PpkUuo/J10oyd68zjd6I440dPp+vTWcw/61lG/5dJQ3YfrTe+4YxJKiWid5IKf/kYtl3AL5zs30OgHGhjInCq11nhCnE9bEFleaE2Kn9/BpFR0RERFEsjq3vyIu7LxrpdZvUJMfE6vhBmbZqKDrhpnlbnZZlz16EOb8Zh8vH9ce9X+fiWF07AM8Dumt9GADOCjEiothj3wIPAH7mzQ9R6+92yUx378Z1Mf67fGtR5CQP9EZp+Ts83/Niy/u9ujYdhmV5397fRKm3G6wKq1rRJyPFaflfP83BhsO1KJ57hV/nI+DatzcDQNDfu7UHq/Gnj3dg9yOXKBFWSIW6Qoy6OI3e6PTGR2mHqlqQlhSPQT1TQ3oeIiIiIooN00Zl4YmrxuL6Mwfh7KG9bMs/uHUS+nV3/pBNrj30wz6c8dQKrD1YY1vWotFDawj8blsO+iYiIoo8JlOEDoNSUfbsRfhht21KkC31c7CyxamSSknukkazPs1xSFiG0q5jDWE5DwCH95Xbi10nIzvPv9taVIcSS/KOwmPe+iIA4WnLGiwmxCiktAYTDCH+pVlS144hvdJ4pzgREVEXMWFwD7VDoCj3yZ8n49Zzs5EQH4e3b5loW9YnIwVbH7xY5eii21VvbsLEJ1fgaG2b2212uLmYQURERJEpx0UChCky4POtJQ6lcjuP1ePSV9fjo03FTtuuP1SD7NmL0NCmc1r30A97Ud18YuaZRu/+5iKN3nXhwfL9VTHZevrOz3f5vc9N87bi/BfWhCAaigVMiFFIafXGkJftltSbE2JERETUNZx8En/vk3JO6paM4rlXYNoo574vP901RYWIol+bzogLX1xre641GB2GvW91MXvEhve4ERERKaKsoT2gSh5f5oJ2Vljdig6dEQcUrg6JtqSbtYX0vnLnFtzvrjsCwHUFzRfbSvDIT/tszx+1e+yJkrPbQsnXl5SrwrpVBdWKxuJFpPTTAAAgAElEQVTuPNEkmsKPxFiZEKOQ0hhM0IewZaKUkgkxIiKiLmbW+cPUDoG6iNMH90CaZc7Y6zefoXI00evG97Zi/OO+DZ+PxXxYeWMHDlW1qB0GERF1MVOfW4NHfsr3e7+CSv+TWr97fxv+vmAXLnttg9/7+iKQJF2gPFVn+epARTOyZy/Cxk6t/DyxT9L433Yuut9BhfPfV2kr9lehsLpV7TDID0yIUUhp9EboQ9gysaZFC63BhCG8U5yIiCjmuJpDVDz3CowdkKlCNNTVXTS6j9ohRJ3ff7ANAJBb2uiwfN2hGofZGkaTxPpDNYhVU+auxoxX1qsdBhERkU82FXqo5PZg+9HIaomsDTCxlVd2oror0Iq3gkrzjTAr9lcGtL+vHvrBuZLsjs92hvSc/vBUiTX7uzzc980el+tMJhnSOWxK+uunOZj+8rqwnjPS84eRnuBkQoxCRkppToiFsGViSb25FHkwK8SIiIhizvuWwbxEarjYkgA7d3hvAEBCnMD/7p6Kh684FVsfODFn7H93T8V/Z462Pf/HxSPDG2gE21hYiw2HnRNdOcca8O9v9uC851dja1Ed5q0vwh8/2o5f8o7D6OVmOpNJ4tudZTCEuC07EREReVbvYhZWqKw6UIV7v8r1up19dZcS9+eHquLNFaXSP0vzQ5uEA8wFCtNfXoeyhna/921o0+FwVQsW7ijFtzvLADgnzoY9uBi3frxDiVBtGtvD93oNxAcbipA9exGaOvTeNw6hN1cfVvX84ZCgdgAUu/RGCZNESFsmWhNibJlIREQUe1q1wbcrIQpE3uMzkJpobpX4xs1noLyxHSmJ8ThtUCZOG2SuUFz172moaNTgtEGZSE2Kw3NLC/Dm787AleMH4PVVsf9B0ld/+HC7y+Xf7yoHYB56bnX3l7s9Hmt1QRX+PD8HALBwewm+/b9zFYqSiIiI/NWiMYT8HNZCk69zzImTV26c4HH7i1+K3EqdcBc8NXXoIQTQPSUxoP2rWzRIS0pAt2Tn9MEPu8tRF2BC9IynVrhdZ19ZpHT3gAlPuj+vJ7WtWpQ1dGDC4B6KxtPZgu0lAICaFg0yUwP7N1PCi8sPqXbucGGFGIWMxtLmKJQtE0vq2yEEMLBHasjOQUREROqIliHRFHu6pyQiMd78USk1KR4j+mQ4bTM8qxumjjRXj43ok4HiuVfgyvEDwhpnV3LGk8ttyTDAXGVW1azxul91swZXv7kR1T5sS0RERIGLhHfu5Y0dQR/DU6s+V20hDUb/vvJwdZM7/YnlPs9wdWXynFW47DXXLZ/VaomnVFLRehj7r0OjN+LZxQfQrnNM9F795iZc89YmZU4cAYL5jJ1X1ohmjX8VbJHY+pIJMfLbpsJa3PfNHq/tTLR6c2VYqFsm9uueghTLHbxEREQUQzq91Zh+Kmc4UXT48a4paocQcxranT98n/3MKrfbrzlYjZeWH8Tn20qwp6wJ932bh2aNHu+tO8LkGBERUZTofOVx9CNLQn7O1Qer3a47WNXitOyFZQUAgPzjzU6JonadET/llvt03mDyBt4SVDNfXY8LX1zr93FL610nGNXKcSh1WmuSRtilJz/fegzvrS/CO2uPOGyrRJI1EnV+yfyUW+6xy8Xy/Epc9eYm/NlNK8sIzHu5xYQY+W3Jvgp8u7MMP+72/B+6tW+vlPCaPAtUWX0H54cRERHFqFat4915z//2dJUiIfKPfUuVL/9ytoqRdF23fbwDb6wuRH2bFoC57c55z63Bs0sKnFozfrWjxOUd30RERBRZNPoTN9236wzInr3I7bbf7SoL6Bx1rf61ArTetFPbqnVa983OMvxzYS52lTQEFItSCipbcLS2TdUYIp3eUumn66Jzav+5MBcvr3DfLnHWZzsBALtLGz0e55YPttlGHEUqJsQ82FpUZ+vfGUsqmzQoDeKFWdFovqPylZWHoPMwH0xrODH3I1RVYiX17ZwfRkREFINMJokvtjm+D+uVnqRSNET+mzy0FwAgLk7gw1snqRxN7Hpj1WFkz16E7NmL8POe49hV0oD/7TluW//51hP/j1iHlLd0Srb/97u9uOG9LeEJmIioiymobLY9NoVwpAZFgDD981pvuvd20b2iKbCK8GAqXdzNVWvTGrClqC7wA6tIozeiqKZV7TACYi3WoPDaY5c0i8T/9ZkQ82D+puKYHIj9xP/ycc9XuQHvf7xJg97dklHW0OExYWh/10YosusavRGVzRoM7smEGBERUaxZml+pdghEQUlPMrf0TogTuPjUvi4TusOy0sMdVsx5ye5O1n8s2I1r396Mvy/Y7WEPz8oa2pE9exEe+H4vlvP/ISKioM18dYPt8bAHF0fthXWKHEv2Vagdgk3nVoWP/pSvzHHDNmnMu78v2I2LXlrnUPjg6wyxzsnFcM+TuvWj7WE9X7go8V0M5b+E2hWR3jAh5kFFswaGGLx7pbpFi+YO/wbg2ato6sDMcX1x2sBM/Gx392Vn9ll4fwdM+qKswdzDdchJqYofm4iIiNTFu/ko2r1w/en49yWjcObJPQEAw+2SX5eO7QsAGNiD72PVcKDCXK0gpURbp2qx9YdqAQALtpdg1mc7sbqgyufjljVEdnsYIqJwe3Wlc/ut/OPNLrYk8p2nblVRwW0yKfBrp6FMn208bH5vFMw4HG8JtFBdfd8WSEvsCE4FCF8zkZ6OEYZk645iu4RYBH4/mRDzoKKxA4YY7BvaotEHXLHVoTOisV2P/pmp6JOR7PFilX2FmH3LxHadAQu2lwR9V4C17SNbJhIREcWezi1Qfvn7VJUiIQpM727J+PvFI11+cH34ijEAgFnnD8MDl43GjZMGhzu8Lu+zrccw9IHFGPvYMoflx+od52v8eX4OSuqcE11SSnyyudh2t/SmwlpMfW4Nfsr1PGeZiKgreH99Eb7OKcWrK2Ov6xLFPunhCv67a48ocQL/NpcSzyw+EPx5QyichV8Lt5cge/YiRcbz2L9NDzbXdNaclfhgQ1HA+/vyLfR0Lb1dZ8DjP+ejXee6badSwl3lFwpMiLmhN5pQ06oNSWWT2po7DNAHeDfF8SZzVdaAHilIiBcu7w6oaTEPkXQ3Q2x1QTUe+H4vDlcHVyZ/IhbeWUtERBRrOl9AGTcwU6VIiJRhXw02uFcaiudegfNGZuFv04bjud+Ox9r7LsALvx2Plf86HzPG9FUx0q7hkR/3uVxeUNHitKxZo8ef5+/Abrv2L59uOYbHfs7HOEtCzVp1tqe0CQDwwrIC3PLBVqXDJqJOhBAfCSGqhRD77Jb1EkKsEEIctvzd07JcCCFeF0IUCiHyhBAT1Ys8ts1ZfAD3f5undhgUZqG4gurPtffPth7z+/ibC2tdnNT99uWNHX6fw1e7ShpR1ew89+xQVSvmrQ880RJTpMSzSwoAwKnKX201LVo8vUiJxKX3zJyrLT7aeBTzNxfzteIDJsTcqG7RQkrEZMvE5iAqxCoazf8x989MRUJcnFM2fk1BNc5+ZiXKGzs6VYid+D5al7doAm/bCJxIvPXulhzUcYiIiIiIQm3Ob07zuD67dzqunzQYI/pk8IYvlfz10xysO1TjtLysoR2rC6pxr90c5v2Wll96o8Txxg7bBRAhgJ3HGvDWmiPYVFiHg5XOCbYNh2vwbITf6U0UReYDmNlp2WwAq6SUIwGssjwHgMsAjLT8mQXgnTDFSEQK0+iNqGvVOSx7fZX/FYnBtvBU8rJxfZsO019a5/P21S0nkmdfbCtRLhCfRM6MM6VYk6/7K068JjxVC4bKlW9swHNLC2zPz5qzEp9sLva6n/USvSnEuYxYyJQwIeZGpaX6yGCKrZaJeqMJ7TojtMFWiGWmIiFeOCUMtxTVwSSByiaNQztF+8SZ9XGLJrhMfk2LFj3TEpEYz5cxEREREUW29OQEn7edfdloPHXNONw2Jdvlet4QFhor9rubF2a+6GP/ycdkd8v6e+sc2ydd985m2+PO7V8B4A8fbsd7vHuXSBFSyvUAOg+JuRrAJ5bHnwC4xm75p9JsK4AeQoj+4YmUiJQiJXDTvK245YNtaoeCncdOVI9bb9wPRouPVU9Gk8TkOauCPl/glE2L+JpeC2Uyxlqdt+HwiapB+2KPcNHoTXjHrjVnTYsWj/2cH/Y4/KVG8jBQzCS4cdxSCaU3ypjojWllTUIF2mfVWiHWNzMZCXFxTi0l95Q2AjCXrWrctEy0zmVr07qfP+aL2lYtsjJ4MYCIiIiIYktKYjz+cM7JeOzXY/H1336FZ691rC578frxKkXWNd3x+U4AwLG6dmTPXoRXVhzCNzvLbOvt58R9uPGow753frHT5/N8tPEoKppC14qJqAvpK6WssDyuBGDtQzsQQKnddmWWZaQAKSV22bWWpa4nnNdPcy3XH0OhpjX4xJZHChRXmaLsWnWkhWuNJ9Lr3BZsD3fln3dS+tf1LcL+6QEwIeZWZdOJstNY6ppofcHqAqwQq2jqQO9uyUhOiEdivHBIdBlNEvvKzT3z27QGty0TdZbHwfZ6rWnR8u5YIiKiGGT/PgwA/nreUJUiIVLWqL7d0Ltbkl/7TB7aCzdPHuKwLDkh3uH5T3dNCTo28t1rfrRksv8c9POe48g/3uS0jc5gwpurD+PJX/bjV8+uBmBuBfXUL/vRGsRnpt+8vQkjHlwc8P5EsUCar9D7fVVHCDFLCJEjhMipqXFupUrOFu4oxbVvb8bXO0q9b0wUAkaFLuDaVwiRb77Z6dvPvf1NRPbCfendWs30wcajqhTCSCmxuqDKVjTiSofOiAe+3xvGqBy5+acCADz2k+8Va0dr2xSIRlm+9+3oYirsLsTojSbEx8V72Dp6NHeYP1CZpPkXRXycf7nw400aDOiRAgBOLROP1raiTWeu+mrRGty2TLT+sAfz4Q4Aalt1OGNIj6COQURERJHn482OFRb3zxytUiREylp+77SA9/3s9sn4w4fbcdm4fhjRp5vDOuvzGWP6ok/3ZHy+NfLuJo1l832Y6wAA/1iw2+F5eWMHpsxd7bSd3mjCl9tK8OHGo0iIF3jgslMd1n+48Sg0eiPuunCEx/PtLgnd3fNEEa5KCNFfSllhaYlYbVleDmCw3XaDLMucSCnnAZgHAJMmTYqh26RDo7Fdh5eWHwIA/C/vuMdtPV1kJQpGfZvO+0ZRwv7nJBp+Zj7dcizgfY/UtOLLbYHvH6zGdj16pvt3w1owqps1+GRLMd5acwT3zRiFuy8a6XK7QKsAw/ELq6nD9wqxSMSEmBv2rSo6z8mKZs12JY06gwmpSf4l+ioaOzAsKx0AkBAX55Do2lN64m7HNq3BYU6ZqxlirBAjIiIiV95b5zhbh/NCiYDzRmaheO4VtufFc69A9uxFAMzzydbedwH6ZaYgJTEeN501BFe+sdHpGL/8farL5aQOV8kwABj50BLbY2uL+r98sgMXnNIHGSkJeOqX/QDgNSFG1IX9DOBWAHMtf/9kt/xuIcRCAGcDaLJrrUhB+PuC3agNdZs56pKMpvDPcAqFSGsZGLzAsnSuqrF+/cZGtFsKLDYcrvW5YiuU39PNhXVOy+rbdLj01fWYf9tZGDsgM+BjX/baBtRZkrdlDYG1yu78pRtN0imBdqCiGW+uLsRrN01AAj9PO2BCzA37CjGj0ftPmM5gQkKcQJyfFVfh1twRZEKsSYMpI3oDABLjhcMMsbyyRqQkxkGjN5kTYg4VYtLpcTAVYm1aAzr0Rs4QIyIiIqIu68e7pmBTobmtT3bvdNvycQMzcf2ZgxzmXAFARgo//kWbFfurMHNcP6w8UI2VB6q972DRufUsUawSQiwAcAGA3kKIMgCPwZwI+1oIcTuAYwBusGy+GMDlAAoBtAO4LewBxyh//s95+Md9IYyE1GTtGqWkNQdD27J057HwzL2LtXyYr1Vr1uSWp+3bO71uiuvaPRxPmYq5eeuLPK6/88tdTss2HK5BTYsW932Th8X/mOq2/aM3dUFUMro758iHFjuNfLpnYS4OVrXg7xePwOh+3W3LpY+vRl+/uvo2HYrrIq8toidMD7ph/8tc7+VuhCM1rbjwxbV44n+e+2euKai2zdhSS4vmRBJK56FPqSvNGj1atQa7lolxMNh9b/aUNWH8oB5Iio9Dq9bo0DLR4KJCLJiEWE2L+c6jLFaIERERxbTTBwV+9x1RrJswuIfbKqFbzjkZALDyX4G3aST1ldS34/p3t7hdX92iQfbsRbjstQ14a00hvtphbpe5v8L75868skaYYqgbCnVNUsqbpZT9pZSJUspBUsoPpZR1UsqL5f+zd+dxctRl/sA/T1V199zJTI5JyEFCDsIdJASQSwgoCCsiooAHnvEA12tVEGFVQHFXxXXdZUXxWH+CeACynAJyKHIFCCTcuSAJueee7umu4/v7o46u6nuu7pnJ5/165ZXp6uqqbzdJ6O6nns+j1CKl1ClKqQ5vX6WUukgptUApdYhSalWt17836kqO76gtqr2R/D/XPS9sH8GjFbc9lEQmEPQMmPjk//KfoEIqLcQM58/B7r6hF6Ve2taDm56szazEYt1zQ3k7N1ItPedc9w+857//MUJHq45hF8RE5FwReUFEHBFZlnPfpSKyTkReEZF3hLaf5m1bJyKXhLbPF5EnvO03i0j1AjxDLNvBzt6BYOB1qaGMr+7oxft/+hi2dqUiXWWF/OvtL+CnZSrQoy0SmTjIgti2Lvf5zZxUDwCIaQLTVlBKwbQdvLitB4fOmoSmOgN9aRMD5uhFJu7yWvGnskOMiIhoQglfUAMAN3/qmBqthGh8WzpnMjZdc0bevDEAmNNWjx+9f2lw+5GvnFTNpdEImXfJnVh+9QMA3C9n/v3eV/C1P63BDX/fmLefH6+5flcfdvQM4MFXduJdP3kUJ//goZLn6Epm8GZX6TifDbv6sKWz+NXcPqUUfvfkG0UvjCz1uZuIiMhnDfL7zLFAcsoPNz+5Gfe9uKPCx4491ShaDffco2lNjRte/NfgLy9sx19GqairkP/ZvJCNu8dXdxgwMh1iawG8B8Aj4Y0iciCA8wAcBOA0AP8tIrqI6AD+C8DpAA4EcL63LwB8D8C1SqmFADoBfHwE1jdoO3vTcBQwu7UBQLSY05e28L17Xg6KOdc/sgEDpoN9JtVF9iukO2VW9AdpNOVGJlYibdn40A1P4MJfPAkAkQ4xwK1Cb+8eQMZysLi9GY0JHf1pGwNW9rlmCkYmDv212M0OMSIiognp5e29kdt1scHFOxNRvh+ffzh+/uFlwd+n+VOjRbK5UxqCn9ddfXrw8/9dfFx1Fkgj6so7XsS/3l44vWTFDx7GUd95AP/94DoAbiyR/7lQKRW58rhnwMTSb9+Ht17z15KzgU7+wcM47nsPRrZ1J828q5hXvd6JS25Zg8sLxKU9vmEPFnz9Ljz9ekdlT5KIxpTw3/b1O/tqtg7aO1xyy5paL2HQ/uZFXAOVR9aNZTt7azMz8K6129DJLtPAyt88jZW/ebrkPkOdtaYUsOTyeyquH4wnwy6IKaVeUkq9UuCuswD8TimVVkpthJvRvNz7tU4ptUEplQHwOwBniRuCeTKAP3qP/zWAdw93fUPhd3rNaXM/GIbnZP1x1WZc99B6rPIyZlMZG9NbEpgxqQ5WiSvalFLoS1s1/0PUE4pMLFfA823pTOFvr+3G3CkN+PSJC3Do7MkAAN2bl2baDtLe80rENDTGDfSlLQyYNupi7h+xQpGJI9MhVpMmQiIiIholV97xYq2XQDThvOuwfXDKge1ob6nDLz9yJH5yweHBlzFLZjRH9jV0Db/4yDLc/6UTccjsSbjiTPfaxfmhGWU09m3uKN3V9dSm7MyU1725D4dfeR/mX3pXsP3mUBzQsqvux99eq2yOy+aOJA779l/yOtX8GSGFimuPvOoe+7H1+UPsiWh8eZMzDIny/N9zbwY/p00H/1i/u+i+n/3t03h+S207kEZKxnKQGsHZcht2RbuR1m7tRu9AdQpklc4M29adwlV3vFizppihFsCKKZQwt7kzicc3jN/3bKM5Q2wWgHCg5hZvW7HtUwB0KaWsnO1V588Pm9PqRgOGC123PLvV3eb9YbAcBzFNQ0zXSha7khkbtqPGQEFs8B1i3V5X2WdOXIBLTl+CmNcZFtPdfwgsRwWzxGK6hqaEgf60hQHTQVMiBiBafLOCDrGhF8R296ahCTClkR1iREREE0m1BlsT7a1OWjIdLXUxtDe7qQ/vPGQmAODUA9uDfU5e0h5ELX7suPnYdM0ZuHnl0UGkPADc98UTsGLJ9CqunIbrrjXbCm4XcUcB+HN9dvWmkczkf1b70A1P5m3rTuV/CbW5w41P/MuLOyIXRhabewFku0uGOqB+yeV34zePbRrSY4loeJRSWMeuMKKKXXbrGjz4SvGLTO5aU525ZtWwpz+DA664Z8iPX3zZ3UXvc5TCmf/5d3zsV08F217d0TusBoyRcMx3/4qf/30j/vOvr5Xdd7DFq18/9vqg1zPEt1YlvbqjD+dd//jIH7hKKiqIicj9IrK2wK+zRnuBRdazUkRWiciqXbsqu0ptMLZ5gw6DDjGv2PPajt6gQu/H/lm2gqEL4oaW13GVtmys3+W+Kej1OrPSXoygZTu46ck3qp6T3pPK/qNQ6QwxP2axpT4W2W5o2e4v03KfR0zXvBliFtKWjZY6A0D29XJ/HpkOsbbGeNClRkRERERElXvrwqm48ZNH4aKTFgIArv/QEdjwnXcW3X96Sx1WfePU4Pai9mbc8JEjR32dNHI++9tnCm7vTlmRixWPvPp+HP+9B3H1XS+VPeZh3/pL8PODr+zE2q3dWPum+5n5yY0dWBj6IstPYilV9Pr3e18Z9EWkfd7FmJf/uXBMJBGNrmfe6Kr1EojGlcF2UQ6loFFuRmg5947SXKpKvNmd7XIv9d2141WTwhdUvv3aR3DWfz067DWMRENL/zBGBdHoMirZSSl1yhCOvRXAnNDt2d42FNm+B8BkETG8LrHw/rnruR7A9QCwbNmyEa8offDofbHigHa8usOdYeF3NPndYUC2SGY6CobudoiFiz4A8Ment+Bb//cinrn81KB90/+L/OSmDlx6yxrMn9qIo/ebMtJPoajhdIhNyimI+R1ipq2C5xXTBY0JA290JKGJoDkoiGXP5e87nA6xXb1pTOX8MCIiogntS6curvUSiCa0ty6YGvwsIiN2Ben3zz0M//KH50bmYDTqzrnuH3nb9vRnCu57wOX3YMUB07G5M4XnNke/BP/oL58q+Jiv37oG3zn7EFzqzXx55NVdGDBtJAwN27oH4CiFvlC0f1cyg+ktdRWv3wldXr2zdwC7ezNYOL0JcWM0A3GIyFfpOA4iqp7caMHB+lSZuVSj6YKfPTGsx1ezY/WetYW770fbn57Zio8cO7+ifYt1oQ2moPL7pzaX32kcqaggNkS3A7hRRH4IYB8AiwA8CUAALBKR+XALXucBuEAppUTkQQDvhTtX7EIAfx7F9RVVF9Mxf2ojNu52/wJZjjtc+LZnt2K/qY3YsLs/6OyybAcxTRDTJe9NwK7eNDKWg87+TDC7K226+/j5qeE3/tXQkzLR2hBDZ9KsuCCW7RCL/nExvOhEy3GCKIyYrqEp7kYmxnUNU7xYlUKRicPrEMtgWjMLYkRERBPZP69YVOslEFGOP190bORq3Ya4HsyGAoDJDTG894jZWLFkOn731GbYjoOzls7C8f/2YOQ4nzphP/z0kQ1VWzeNjJRp447nB/flz41PvIHvnH1IZNs3bluLPz69peD+jgJ29AzguofW4yNvnYdNe/rxzBtdeHzDHmztTOGCo+YGnY2A+wWD79O/eRrPvNGFC46am3dOwP38fv9LOzBgOnj34TWZ0EBERLTX+eWjm2q9hGErdN3YP9+0euROoEreDFLnAGDN1m6s3jy07lwJPZNKxxX85MF1QzrXWDXsgpiInA3gPwFMA3CniKxWSr1DKfWCiPwewIsALAAXKaVs7zEXA7gXgA7gF0opP9vgawB+JyJXAXgWwA3DXd9whCMBU6aNbd0DuOCoudiwuz8Smahr4s4QyymI+UWvrqSZ1yGW9opRqSoP2OsdsDC1KYHOpFnxVTx+MS+3Q8zw4gotWwWvR0zX0Jgw0J+20RB30BzMECsQmZix4TgK2hBiD3f3prGAg72JiIgmlJ29HMJONNYdNmdy5PZjl6zAB294Amu2ujF59TEdANDaGMdn3rag6HEufecBeHzDHjw3QYbGU2m53WTFimEAcOUdL+JOb97Zr/6xKe/+f7/3FfzToftg7pSGvPv86LbVRSLcPvG/q/CQN7eFBTEiItobFBvX86P7Xx3UcQ684t4hr8G/eGqwM7MqMdxDbtrTj8OvvA/HLhxMglt1RyABwP7fiM5i29aVKrJnVKkEiEIpAblKzYANe3xDR0X7jQXDzhBQSt2qlJqtlEoopdqVUu8I3Xe1UmqBUmp/pdTdoe13KaUWe/ddHdq+QSm1XCm1UCl1rlIqPdz1DYcRigT0CzqNcfcDnt8RZToOYrqGuJ4/Q6zfG0TclcoEM8T8riy/qpvKVLcg1jNgBl1bg4lMrItpSBh6ZHvM6xAzbQemFyFp6BLMEEtlbDQm8iMTzdA/xP0FhjWXo5TCrr40O8SIiIgmmFufKZiWTURj2KSGGGa31gMAjti3Fb/9xFEVP7b6XyVQrQxmnodfDCvlhH9/ELt605h3yZ1BgSvsxW09+NkjG/I+oxfal4iIaGzLr2hYduXvohZ8/a6C2390/2tDXtFQWUWKc7V0l/e+49F1e2q8kpGhKnyHffWd5WfFlvPCm+PzwjaGapfgd4jZjgreSNfHvQKPk+0QM3SBoQtMK/oHzq9+dybNoCDmd4b50YnJIRSEhspxFPrSFqZ4s7dKDSYM606aaKmL5W33C4aWo8Y5sJMAACAASURBVGB6zyuua2hKuIWzjmQG9XENhhaNkzRDhbihDBjsGbCQsRzOECMiIppgvnv3y7VeAhENwVXvPhifOnE//P5Tx2C/aU1DPs7VZx+ML5yyCFe9++C8+565/FQkOBOKQo68+n4AwOduerbg/Vff9RIWXXY35l1yJwB3dlnY+/7nschtpRT+7Z6X8eKbPXnH+vPqrVWdSUJERFTKod8aerdWLf34ryNfhBtu19lodK1VQ7FlOwrY3ZftMSr2/NIVNsqU8tj68VlEHM0ZYuNe0CHmOEFBpyGnQ8xyFAxNQ6xAh5jf/dWdzKDf+znbIeYVxKoYmdibtqAUMM0viFU6Q2zAzItLBLIFQ9N28iIT/ePXGToMXSJXLlhO9rx9Q5gjtrPHjVNihxgREdHEMZDznuivXz6xRishosGa0pTApacfUPH+93/pBADAKQe04/lQZOIHjtoXgPt+/xu3rQ22f/TYeWhrjGNxe3MQzUg0GL978g1cc0/0oosnN7nRPmnLxk8f3oAf3udGR/33Q+vx9DdOCS4kBYDP/86dEXLNew7BlKYEJtXHsHx+W5VWT0REFGUOokNsLBmvxaeiBj8FaNRd99B6XPfQerTU5Zd93nHtI3hlR28NVjW2sCBWQszvELNV0P3lZ+JbwQwxBzFdChbE+kMzxAa8iMR0zu8DVYxM7Em5c8ymNHqRiZV2iKUKF8RienaGmBWOTExk/1jVxfS8+WqZ0D/a/UMoiL283f2Lu3D60K8+JSIiorEl98r94XSZENHY8/Q3TkHc0DBgOsGFbR88et+gCBFWH49Gtftfnlx6+hJc8PMnRn2tNPFccsuaovflzuQAgD89swWfPH4/mLaKjDm4/pEN2LC7HwCw6hun4D/ufw2Xn3kg4uxepL3YhPuCm4giUlVs5hiMzR3Jqp6v1CyusajHS6v71aOb0DNg4roPHsFimIfv2krQNT8SMDsjyy+I+bctR8HQNcQNLa86nwpmiGUjE01bwXFUKDKxih1i3hr8K93MQcwQaynUIebNELMcFXSbuZGJ4YKYO18t3CFmWg6avX2GUhB74c0exHTB4vbmQT+WiIhorBGR00TkFRFZJyKXFLg/ISI3e/c/ISLzcu6fKyJ9IvIv1VrzaLh77fZaL4GIRtGUpgSa62KRlIfw54aw5roY/vrlE3HJ6Usi29+6cCr+47ylAIDl89idQ8P3/p8+VnD7d+56Gdc/sgHvue5RHPbtvxTcZ9lV9+M3j7+O+17cMZpLJCKivdx4K8RUyznXFf5/+GBV+vqO+ufVQf53rnT3m1dtHtbaZQL+AWRBrAS/A8q0wzPEoh1ipu0gpgliuuR1iCVDHWJ+MQpwO7OGEpm4enMXHnx55xCfjRt9CABTm0amQ8zwC4a2EwxFDEcmAm6HmJHz2liOg8mN7vF6h1QQ68ai6c28Co+IiMY9EdEB/BeA0wEcCOB8ETkwZ7ePA+hUSi0EcC2A7+Xc/0MAd4/2Wkfbrc9uDX6++uz8+UFENPHEDQ2brjkDi9uboOV81t5vWlMwM0yF2g/OWjoLm645A5ed4UY0nn34LDx52Qp86dTFOG7h1KqtnSaGJzZ2FL3vu3e/jLVbo/PE/O6wsJ//fcOIr4toLDr/+sfxgZ8/XutlEO11Vr/RVeslEIA7n9+Wt63ScUQAsGFXX+Q97XAN9kh3r8lff0XnUWrCFWVZUSjB7xCznWxkYl0sZ4aYraBrbmSi5bjdXz6/INadyqDXK0YB7vywoUQm/teD6/Cdu14quc9fX96BPz69JVjjF29ejVe8iMEgMtHvEPOKeg+/ugvJTPHCVE+5gpiTLRjmRiYmCkQmmrZCa4NblBtsh5hSCi++2YOD9mkZ1OOIiIjGqOUA1imlNiilMgB+B+CsnH3OAvBr7+c/Algh3mVaIvJuABsBvFCl9Y647pSJV3OiG/w5QkS0d7j3Cydg3dXvzNvuf/Yu9IH/sDmTcd8XT8APzj0M05vr8M8rFmGfyXWjuk6iQp7lF5W0l3hswx48um5PrZdBtNf58h+eq/USJrTdfZlBP6aSutZvn3gdALBpdz/ueP5NnPyDh3Hjk2+UOOiglzEon/ntM6N7gnGEBbESYl4koGlnIxPdeWESdERZjgND17L7OtnCj19k6kqaQW4n4FaPgw6xQRTE+tNWMIusmF//43Vc/8h6AO5f6Fuf3Yr7X3IjHPw1+DPE0paDnb0DuPAXT+L21W8WPJ7jKPSmrYKD+IzQ6+NXxPM6xAz3tYlEJtoOJg+xILazN409/RkWxIiIaKKYBWBz6PYWb1vBfZRSFoBuAFNEpAnA1wB8qwrrHHGOo/DgKztxznX/wNuvfaTWyyGiGhIRaLktYshGtBT70mFRe3PkcZITHrPxu/lFtlx6gfMSEVF5H//VUwXnQBIRjSfhpJKR5DeivO37D+HiG58FAFx269oRO/54mt94wc8exwn/9mCtlxFgQawEQw91QIVmZBmaFhTETFshpgviQXEov0MsPEMMANKWnZ0hNojIxGTGLtuK2TNgBmvwu7a2dw8AQNClNqk+hriuIWM56Em569rTX7ga3jtgQSkUnCHmR0patgpFJhbqEItGJpq2g9YG93h96cHNUHvhzW4AwEGzJg3qcURERBPQNwFcq5TqK7ejiKwUkVUismrXrl2jv7IK/PIfm/DRXz6FdTvLLp+I9lJ+PIuq8JLZ3DgXEcHfv3YS/uO8pUFsfCIndv3ikxYOe51ERBPZw6/uClKOwh54eSd+/MBrNVgREQ1XOMmMxqdK3x+PBf9YvwdvdCRrvYwAC2Il6JFIQK/gY2iRmVi2o2BoWlA88wtnSqmcGWJmcLxMKDIxVSKqMFcyY5UviKXMYB+/C22bVxDrSrr/2DXVGUGRKuWtMVywixwvVETLZWjuHx/LcYLnHdO1SEHM7xAzIx1iCk0JA5oAfenB/QP8gpfhvmRG86AeR0RENEZtBTAndHu2t63gPiJiAJgEYA+AowD8m4hsAvAFAF8XkYsLnUQpdb1SaplSatm0adNG9hkM0eYx9IaYiMamwfZu+QWxC4/ZF3/89DEAgNmtDThr6Sx87bQlAIDbLjoWm645A59fsQgA8J635DblEhGRb/XmLlz4iyfx3bteDrZ98OdPBFFgAEqO4CCisemQb/6l1ksglC5qjeS8sbHizue3jYnnxYJYCTG/4GM72RlZ/rywUBeWG6OYjQ8EgIztwHYUNPFniFlo86IKM3Y2MjE1iA6x/nQlHWJWsAb/9x09bkFsa1cK05sTiOka4obbIea/cSl2ZUC3N3esVIeYaavI61MX04Kh2HUxHYau5XWIxQ03WrF/0B1iPZg3pQHNdfnrISIiGoeeArBIROaLSBzAeQBuz9nndgAXej+/F8Bflet4pdQ8pdQ8AD8C8B2l1E+qtXAiotH27sNn4aT9p+HikxZVtP+0ZneG2JHz27BsXlvkvnOXzcHqK07FATPd6PUvnroYm645A/tOaQz2+cBRcwEAR+8XfSwR0d6qM+mmCW3c3R9s+/u63ZHYr4//elXV10VEtLfLjQofLSNZvrroxmfw2ydKzFGrEhbESvC7vmwnW/CJ6RoMTWB5s8IsR8EIRyZ60YF+59X05jqYtkJ3yszO7jKHNkMsmbGQsct3iOUWxPwOsc0dScxpawieR8ZygoJcT5EOMb8gVrBDTA91iDludKSI+8ufI1YX0xEvEJkY0zU0Jwz0DXKG2IvbenDQPoxLJCKiicGbCXYxgHsBvATg90qpF0Tk2yLyLm+3G+DODFsH4EsALqnNakdWsSvD+EU0Efma62L45UeXY8akuor2v/ikhfj+uYfhjENmFrzfn2NcTLHHrfrGKfifDx6BV646DeuuPh3zprifqX70/qV5+3LWMRERERENV7E0t1oYydLb+l21H5lglN9l7+VHArodUO6XNnHDLYiZtoJSKohMjBnRyMR+r9A1c3IdtnsdWtOaE3h5e6/XIeZHJg6iQyxjw7QVHEcVHDo9YNpIWw4Mze/ccteyuy+NjOVgS2cKR85rDZ5HNDKxcIdYT6mCmBbqELOcoEsOAJoTBnoHLNTFvJlrochEy5u75naIVf6Xe8C08UZHkrEmREQ0oSil7gJwV862K0I/DwA4t8wxvjkqixtFxa40WzKDXyYT0dDEDQ3vPWL2oB938KwWfPjoedhvWhMA4OzDZ+HJjR1wlBvDOLUpgdMOnpH3uMPmTI7cvnnl0ThqvymYd8mdefv+84pF2NKZxC3PjM7gdiIiIiKqnsF8pz0Ul96ypuT91ZwhtmnPxBp3wIJYCX6HWDgyMaZrMHTN2+b+wfNjFIFsEcqfDbbP5Ho8+0YXAAQdYhnLQdocXGSiZTtBXGLGdlCn6Xn7+JVjf10ZK/sXY2tXCtu6U5jb5haT4oaGtO0EHWp+4StX6chEP1JSwXJUpCAW7hCLGRpS3nEcx93X0NzIxMF0iL3ZlQIAzPW63IiIiGji4YUvRFRtd3zu+ODnjd99J0Qk+BLi8UtX5O3fVOd+1glfozi9OYFDZhdOsth0zRnBz89t7sL6Xf0F9ztwZgte3NYz6PUTERERUfV0JjMVpb6ZZZLeSnn41V1DfuxIGulgxjEwQoyRiaX4HVCWo4KoQkMTGLrAdFQQm2joWlAM8vfz/1LMmlwfHG9qUwIAkLbsQUcmJkOFs2KxiT1el1fGdqCUiuz3zOudcBQw2ysmxXUNpuUExy3Whlk6MtGPlHSQ8Wap+fyCWMLQIpGJpveaxQ0NTYMsiG3udAtic1gQIyIiGveKvRE+dPbkwncQEVWBiPuZxv8nyv8MF/azDy/D19+5JHKh3pOXnYKGeP71pleceWDk9q0XHYsr331wwXN/4vj5AIBz3jL4LjciIiIiqo5dvWlIBZWiB17aUfExx0CdaK/BglgJIgLdmxdmhSITY1q0QywWniHmbetPe5GJobz7Kd6HqYyVjUzMWA5sp/wf+WQ6VBCzsoWu3gETV9/5IgZMO9LlZTkqiG8EgKc2dQAA5rQ2BM8jYzsYyJQuiPUMmNA1QWM8vyOtVGRiU6hDLByZaIW66hoT+qDaSzd3uO2Zs1vry+xJREREREQ0fIW+65g5qR4rT1gQFM+K2XTNGfjYcfMj21rqYvjQ0fsW3H/fKQ144usrcM05hwx1uUTkEZH9RWR16FePiHxBRL4pIltD299Z67USEdHEdPfa7SXvf35LN17d0Vul1ZCPBbEyDE1g2SonMlFgOyooZBWMTDSzkYm+KU1uZGLacoIOMQBIZsoXhfpD+4QLYo+u24Of/W0jnn69M+jm8vcJt2U+6RfE2tz1xHUNGSsUmVhkhlh3ykRLnVHww57hRyY6jhuDGOoQCwpihhuZGHSIhV7HpkQsKBxWYnNnEnFdQ3tzZUO1iYiIaOz6zeOv521rbcjvSCciqoVqxLmcv3wO1n/nnVg+rw1fOGURjti3De0tdYjpGu75wvGRfX9yweGjvyCiCUQp9YpSaqlSaimAIwAkAdzq3X2tf583y5WIiGhQKokSLNaA4nt5ey/efu0jQzr/N25bO6THDdZIvyVWYyAzkTPEyojpmtttFRRyBIauwbQVLDsbmegXg8ycKMR9JmULYtOCyMTsDDHAnSPWXFf6C6BiHWJdyQwAYHdfOlK0Mm0nEpm4YVc/DE0w01tPTHeLVEmvcJfM2LBsJyhy+bpTVsG4RCDaIeZGJubPEEvENMR0CaISg646Q0NTQh9UZOKWzhRmtdZD00Y6vZSIiIjGgnu/eEKtl0BEFFEuDueBL58YXAw4GOG5Yr//9DF59y+e3hy5feah+yCZtvHVPz0/6HMREVYAWK+Uer1cZycREVE5b3QkkTIrb/IYDV3Jws0tI+2NPcmqnKea2CFWhq4JrFBxKaZriHkxiqaTjUzMmyHmFbAmN8RQF3Pv8zvE/MhE/4NTqoI5YuEusnB3WYdXENvVm45EJmZCkY5xwz3/PpProXvFpLjhdoiFz12oat2dMosWxPznbHnFwXgkMlGHiDtDLKZpMC13LUFhURPUxXQMDOIfjy0dScYlEhERTWDT2QVORGOE/1mt3EWsC6Y1ob0l+m/XzSuPxp8+89ZhnT/8nf3KE/YDALzvyDl47oq34ycXHI6/ffWkyP7nvGV2RbMscn2P8Yy0dzgPwE2h2xeLyPMi8gsRaa3VooiIaHza3ZfBcd97sNbLqIoz//PvtV7CiGNBrAy3u0kFs6/8yMRIh5imBcUgfz+/gNWYMDC53i2ETQ13iFkOJnuxQMkiBbGtXSmc9qNHsKNnILJPtEPMLYLt6ktHYg9NWwX7zfGKSH5cov88MraKHLdQQawnZaKlSEFM1wQibmSiaUcjEw/cpwUH7dMCEUHMkKAQlvs6WhXMT/Nt7kxhdmtD+R2JiIiIiIiG4baLjsUVZx44pHSKo/abgiP2HZnv2JfMaMbX33lAcHtSQwxnHroP5rRFPxd9/9xDoZeoiPmfV889YjbWfPPt+IQ32+z0Q2ZiwbTGEVkr0VgkInEA7wLwB2/TdQAWAFgKYBuAHxR53EoRWSUiq3bt2lWVtRIR0cTy9OudFe+7t/Qv1z4wkQWxsnRNYHszxDRxb8d0DVaoA8vQ3aIPkO2ASnqdTw1xHZMbYtAEQQEs4xXEWhvcQlmxFstXt/fi5e29eGlbT3SGmJ3dv6M/3CGW3ccMzRCb631YmhMqJiUMDRnLjpy70ByxUgUxAG73l/f6hCMT33/kXNzxOTf33tCyM8QyQcykwNA02I6qKDu0P22hoz8TKeoRERERERGNhoXTm/Axr2hUCyKCmz55NG785NFF9wmnZ4gITj9kZnD7L188Ade+/zAcOnsSAODMw9z7vnb6EjTXxfCNMw/EpmvOQEtdDH+++Dh89bT9847/+KUrSq6xuY4TGGhcOB3AM0qpHQCglNqhlLKVUg6AnwFYXuhBSqnrlVLLlFLLpk2bVsXlEhHRRNGdqk6sIQ0O38GWYWgaTMeNTPTna+ma29lkOdkOsdzIxFTGDiIDJ9XH0JQwkDB0AG73mO2ooEBWLDIxbbnbu1NmZOZYuuAMsQzqYnqw3Y1MzCmIha4ijBsaMnY0MrFgQWzAREuJ+WaGLl5xMFoQC4sbWlA89NcU193ZYu42hbhRug6+udPNK53DDjEiIqIJ6T7ODyMiijhmwZSS999+8XF4y5X3Bbd/cO5hOHnJNMyf2oTF7c1Y3N6Msw+fDQAYMG2sPGG/ILUkrClh4DMnLsDctgZcfOOzwXb/82oxe8uVzDTunY9QXKKIzFRKbfNung1gbU1WRUREtBeqoC9m1LEgVkZMF9iOgmmpIGbC8LqirFCHmH+fX/jpT9tojBsQEbQ2xNFcF4OuCQxNgmjCyV6HWLHIRL/w1ZU04YT+tIQjE/0Osd29abSErtDLWNm5Z3OnuBEY4SsIY7rAtBSSGQuNcR39GbtgZOKA6aA+VGjLZXjFQdNWway0XDFdguJhNDLRi5l0HMTLNCtu6UgBQF40CBEREU0MTew0ICIalLbGeOR23NCCAliuupiOJTNaih5LRHDaQTNw1Pw2XHzyQuw3rQl1MR3HLpyCeVMasWZrN57f0h15zAEzW7BmazeSGRsHzGzBbz6+HMuuun/4T4xohIhII4BTAXwqtPnfRGQp3NSmTTn3URH+BdtERDQ6xkCdqCrUGHim/OahDF0TWLbbDeZ3NMW8rih//lVMl6A7yu+ASpkW6uNuIeljx83Htm63oBM3tKATqzWYIZZfiAKiBbHwfK5iM8SmNmev9jNtB6blrm/JjGYAwOL25uD+cIdYe0sdNuzuR0+BNs4B0y5a6HKfuxuHaNpO0cgMv4ColMqJTHSfUyVzxPwOsXBRj4iIiCaOhhjflhIRDdbSOZMxUCSCf7AMXcPNnzomsu23n3AjG1dt6sB7/+exyH2tDXH84dPH4Iwfu8PWC3WfDceXT12MH9z36ogek/YuSql+AFNytn2oRssZF9Zu7cb+M5rzEoCeeb2rRisiIiIaWZwhVka44OO/ITB0zY1MtMORiTkzxDI2GryC2PL5bThr6SwAboSiP+trsjebq9gHGL/w1ZnMRIpmflHJvw9wO8W6k5mgyGTaChnbhq4J3rpgCh748ok4YGb2isC4rsO0HKRMG9Nb3A8uuR1iftHPj3osxPA76GwFQysemeivyQpFJgYFMbuCglhHCvUxHVNyroIkIiKiiWFSmWguIiLKd9tFx+KeL4x+5OyyeW24/kNH4C1zJwfzxv7lHYvzYm9+csHh+OH7Dotsu+ikBfjyqYuD2/tOiaZ+3P3543HekXPyzvn+5fnbiGj0rN/VhzP/8+/47l0vZzfW/kJ+IqIJL2M52Li7v9bLGLSf/23joB8zFiITh1UQE5FzReQFEXFEZFlo+6ki8rSIrPF+Pzl030Mi8oqIrPZ+Tfe2J0TkZhFZJyJPiMi84axtpPgFn4ylgoJYTHMjAM1QZKIf/+cXsfrTdsGowbihodfrEKs0MrE7ZaI/nd3HP4ftKHSlTLTUGbAdhdc7kkFsRsZy1xfTBSKCBdOaIseOGYK07SDpdYgB+QUx//ylOsT87i/TdorOAct2goVfs1BkYqjAV8zmziTmtNVDhEn1RERERERE1fb2g2bgls8ei8++bSE2XXMGFk5vDrrCjl80FQBw5qH7BNGMS2Y0Y9M1Z+Ar71iCz61YhIe/8jYAwCkHtAfH/NVHj8QBM1twzTmHYvUVpwbbb/rk0ZjeXIcfn384bl55dMH13BsqBF5x5oEj+lyJ9kZ7+twLrtdsZTcYEVE1rXq9o9ZLGJLtPQODfswYqIcNOzJxLYD3APhpzvbdAP5JKfWmiBwM4F4As0L3f0AptSrnMR8H0KmUWigi5wH4HoD3D3N9w6ZrGkwnGplo6NkYRcDtIsudIZYyLTQm8l/ehKGjxys8tTb6kYmlO8S6khmvsOVWUf3tPSkTSrlRiKte70RX0sQBM1uwszcN03aQsZy8NvdgHbqGjOVGJjYlDDTG9SDK0ecXxBJGiYKYNx/MsoufK4iTtFTQQefGTHrdbBVEJm7pTGFOK+eHERERERERjRUzJtXh7187CTO8iywBoMn7HLxgevSizH2nNOKZy0+FoQtu+PtGNMZ1vG3/6cH9kxviWPutd+CZ1ztxzAI35e5dh+0DAPj8ikV4syuFqc0JHL9wKua0NWBOWwOeuuwUXPHntXjfkXPw7TteHNHnduVZB+HyP78wosckGne8a5LHwswXIiIa/2584g185+xDarqGYRXElFIvAcjr2lFKPRu6+QKAehFJKKXSJQ53FoBvej//EcBPRESUqm0jXUxz54XlRia68X9et5OWLe5YocjEpgIFsXCHWHMiBk2KRyb6Q0u7UiYaEgZa6mLoTplBZGKHF5e4yCuIAcDUJq9DzFtzsWKW/1x6Bkw0xHU018WCdfn8ddUV6HTzGd6MtVKRiTFvDf6a/PP7+5frEFNKYUtHEsvntZbcj4iIiMan9x4xu9ZLICKiIZqdc+Hi3CkN+M3Hl+OIffM/v7U1xuE4CsvnteHTb9sv7/6mhIETFk/L2/7FUORi2LTmBK774BEAgENmTcKard2R+2/65NE4/2ePAwDu++IJOPXaRyp6Tl84ZVGQaFJOKyN/iYiIiMaNaswQOwfAMznFsF96cYmXS7aaNgvAZgBQSlkAupEz/LQW3A6oYpGJ2RliuuZ2cAUzxIpFJupaEE1YF9NRH9PLdoh1J02kMnbwRjttZjvHAGBxe/bKO3/GVrkOsfBcr/qYjpZ6I5ht5vMLYokSkYn+jLVMicjEWIHIxJiuwdCz885K6U6Z6E1bmNPGDjEiIqKJ6N1LZ5XfiYiIxo3jF01DQ7zw9beaJvj9p4/ByUvaC94/VP/3ueOCn5u9i1MP3KclGCuwqL05uP+Jr6/A8998O16+8jScvGQ6cn3hlMIFuK+etj9u/exbI9vOXz532GsnGqse37AHwNiY+UJENFHZFaSn0cgp2yEmIvcDmFHgrsuUUn8u89iD4EYfvj20+QNKqa0i0gzgTwA+BOB/K18yICIrAawEgLlzR/fNp6FpSGYsr0PMj0zUvMjE7AwxEUFM15DxijvJYpGJsWyHWCKmoT5ulJ0h1pUy0Z+23Jlje5LZDrF+9ziLQ2/s/Qx3M6erLVc81DlWHzfcDrF04cjEOqNEh5hXMKw0MjEbMylBh1i5v/SbO1IA8q88JCIiovFlV2/hsIDjvNkzREREw/HHTx+DTXuS+NbtbtShCPDQV96GAe8z980rj4auSTBHGwgS4fDhY/bF/z72ejAP7S1z8zvcPvu2hXnbzuJFHTSB/fThDQAQfP9FREQj70M3PFnrJVTVK9t7sf+M5vI7jpKyBTGl1ClDObCIzAZwK4APK6XWh4631fu9V0RuBLAcbkFsK4A5ALaIiAFgEoA9RdZ0PYDrAWDZsmWj+n/loODjhCITNYFpO8EbAr9QFve6pQAglbFRHy/cIea/j0gYGhriOlIZK28/IDpDrC9tYVqzW+zyC1WdXofY3LYGxA13JtgUryCWsdxuLH9tucLFKzcy0UBHfyayTyUdYoamecW38pGJpuMEzynaIVY6MnFzZxIAMKetvuR+RERENLb1pQu/5yEiIhoJy+a1Ydm8Nnzz9uzsr5a6GFrq3LSVo/YrHkKT+8l5/xnNuOLMA/HtO17EnLZ6/Md5hwf3PXbpyXj2jS4kM3ZNv9AhGkk1nlhCRER7iR09AzV9/zQqkYkiMhnAnQAuUUo9GtpuiMhU7+cYgDMBrPXuvh3Ahd7P7wXw11rPDwPcgo9lK5ihyMRwV5S/D+AWxvziTn/aRkOhyMRQZ1bCcCMTU2VmiDkK2NGTRmPCQFzXIoUyAGhtjGOaVwibEswQU16MYeHurmiHmI6Wuhh6UoPvEIvpedvFjAAAIABJREFU/gwxB7EykYnRIqKWnbtW5kqjLV5BjB1iREREREREVKnCn1CjvnjqYsxpq8fxi9zZZX7xDAAme2ML3vuWOZGOsZmT6vHOQ2ZyBiZNSFLR3xwiIqKhWbezr6bnH1ZBTETOFpEtAI4BcKeI3OvddTGAhQCu8GaFrRaR6QASAO4VkecBrIbbFfYz7zE3AJgiIusAfAnAJcNZ20gxvHlhGdsJOpoMTYPtqOwMMW+7P0/LcRRSpo2GQpGJoeJSwtBQHy8/QwwAdvel0RjXg04wwI1MjOmCxriOqV732FSvIGZabmRivEiHWMLI7xDzZ5v5sh1iJSITNS2YpxYr1iEWikwMv2Z+IdEq1yHWkUJLnYFJ9RxWTERENJ4V+n/+bRcdW4OVEBHRRDaYa2sPnjUJf/vqyVhxwHRcfuaB+M7ZhwT3vXvpLFzznkPwmbctGI1lEo1JT27qwLxL7sTmjmStl0JERBPQ317bVdPzl41MLEUpdSvcWMTc7VcBuKrIw44ocqwBAOcOZz2jwe8Gc4tL2U4wABgws/F//u8ZS2HA6+xqKBCZGC5EJWJ+ZGLpGWK+hrjhFsRsd/+uZAatDXGISNAhFp4hlrHKz/UCgPqYjpb6GHoHLCilICKR84fXnMvQBcmMA0eh6LmCaMSikYllZoh1JjGnjd1hRERE492p1z6St23pnMk1WAkREU1kC9ub8dzmrqKx/oWICD5+3PzINk0TnLd8dOeWE41Va7Z213oJREQ0Afm1h1oZVkFsb2BobiSgpYUjE93f/ahDQ/M7xNzIxP50hQUxLzKxOyeq0JfJK4jpkcjEjn63IAYA05rd36MzxIoXxOJ6NDKxuc5AxnaQthzUeR1hfodYXYkOsZiuBR1uxSIT40GHWDYyMa5r2Q4xp1yHWBKLpjOXnYiIaDwbA0nYRES0l/jVR47Emq3dBed6E1FlPvvbZ2q9BCIiohE3KjPEJhJD12DZXnHJK2b5BbCBoCCW7RAzbSfo+GqI59cbozPE3MjEYh1iGdtBS132GI0JIxKZ2JU00droxghOb66DCDCl0YtMtB1kbBWsOVcsEploBDnpPQPZ4lxFHWKaBIXBopGJhl/4UjCtUGRiBTPElFLY0pnCnLb6ovsQERHR2FdmZCgREdGIaW2M44TF02q9DCIiIiIaY9ghVkbMi0zM2A5iWnZWGBDqEIvMEFNImu4srkIdYrkFsYYSM8TSpoP2ljr0DPQFx3MjE70OsWQGi6Y3AQA+cNRcLJnRjLqY10Vmu8WneAUdYv4MMQDoSVnwm7HSFXSIGboEhcFYkXllfgExYzswvW/DDE2CAppVIjJxV18aacvB7FZGJhIREY1nDjvEiIiIiIiIiKiG2CFWhq5lZ4hlIxO9DrFMTkHM0CKRiYXiGfxuK10TGLqGhriBZMYqeO607WB6SyK43Rg3IpGJXckMJnuRidNb6nD6ITPddXjRjabtIF4sxtCIzhDzZ5Dt6BnInt/vEIuV6hALRyaWnldmBjGOApFQh5hdPDJxc0cKANghRkRENM6xIEZEREQ0du3sTdd6CURERKOOBbEyDM0tclm2CmZk+Z1NA6YTuR33ClF+gauxRGSiXxiri+nBcXKlTRuNcQONXmGtIeF2iKUtB0opdCZNtHmRibnncCMTK58htrDd7TR7dUdvsD2YIWaU7hArG5moRyMT/dt+R5lZIkNpS2cSADCHHWJERETjWqF62EKv052IiIiIautzNz1b6yUQERGNOhbEyojpAtuPTNSz3V2AG5moCaBp4chEB70DbkGsuS6/IJbwikt+QawhriNjOwW7pDK2g7ihBV1gfmRi2nLQM2DBdhRavfuia3a7yMLFp1xxIxqZOK0pgdaGWE5BzIFI8ShEwC2C+V9wxYp0owWFL9uB5ajQ6+hHJpbqEHMLYoxMJCIiGt8KdYj9v48fVYOVEBEREREREVEtFK80VAcLYmXomgbLLhyZmDJtGKGCU8yb3dVXoiCW7RBzC2NTvajCLZ2pvH3TpoOEoWNyg9sF1hA3kDDcYldPygQAtNTld4i563CQsVWk8BXdJ/tHr87QISJY1N6MV3f0Zc9v2cF9xRih4xhlOsQylt+1Jt7+fmRi8Q6xbd0DaG2IFYyfJCIiovGjUEP4jEl11V8IEREREUWs29lXficiIqIJgAWxMmK6wHK8yEQ92wkGuJGCMU1C+2owLQc9A26xqjlRIM7Qe6w/l2vpnMkAgNWbu/L2zXaIucdpDBXE+tKli26mV8SLl+kQq4/pQYfb/u3NeHV7L5R3BfeA6aCuxPyw8GuR+3OhfSxHwbLDkYnZ7cXs6csERUMiIiIavzhDjIiIiGhs+sOqzbVeAhER7SVK9N5UBQtiZRiaBkchEvXndzalMnYQnwi4xTPTzharmgpFJsaiM8QWtzehIa7j2Tc68/ZNmzYShobJ9V5kojdDLBOJZSxcdDMtx+tqK/wnLCiIhTqvFs9oRm/awvaeAff8lh10shVjhJ5/vILIRNNWQVeZ/7vlFI9M3NOfxpSm/FhIIiIiGl9U8f/dExEREREREdFeoNbXyrIgVkY4EjC3syll2nkdUv4MsYa4HimW+YIOMa/QZOgaDp09Cc96HWLfuG0Nfu9dmZOxHSQMDZOCyEQdcW8+WK/fhVag6BYzxI1MLDVDTM92iPkWe4PtX9nuzhGrpEMsHBlZLDLR38fMiZ6MadntxbBDjIiIaGKwc971HjyrpUYrISIiIiLfPWu3YdXr+RdpExERjYa/rdtd0/OzIFaGkdMBBmSLZAOmnVcwM70ZYoUKVUB4hlj2pT98bitefLMHz2/pwv97/A089MpOKKWQthyvQyw7Qyxu+AWx4l1oMV1D2rIjXW3F1tEQ7hBrbwYAvObNEaukQyxWoGCYd66gIOZ1rWnRWWyWXfyS8V19aRbEiIiIJoDcyMTffuLoGq2EiIiIiHyf/n/P4GkWxIiIqEoyVm3jYwpXbSiga/kFH78TasB0Il1RcSMbmdiUKPzS+gWmRKjz6i1zW2E5CpffthYA0J92i1lKuYWrI2ZPxvNbutGUMEKRiSU6xHQNyYztral0kSpcEGttjGNacwKv7BhEh5gW7pArE5louZGJMS9a0X9ti80QS1s2egcsTGlkZCIREdF4l1sQm1SfH/tMRERERERERDRaWBArIzcS0f092yEWLkj5kYk9A2bB2V5AtjMs3Hm1dM5kAMBzW7oBAMmMhbRXKU0YOk5cPA0nLp4GAIjrutsh5s0paylwnoShoTtpevsXLmjpmkAkOkMMAPZvb8arXkGsohliFXSI+YUv08mJTPR+t4pEJnb0ZwAAU9ghRkRENO595Q/P13oJREREROQxbQe6FL6wmYiIaKJiZGIZ0YKPH5mYnSFm5M0QU+hLF49MTBSITJzWnMCctnoAwNSmOPrSdtA6mNvhFY5MjOkSOU54HX1ewaxY15aIIK5rkRliALCovQmv7eiDUgoDphPpZCvEKNBBV+xcuZGJflHOcgq3Se7pcwtiU5vYIUZERDTePfzqrlovgYiIiPYiIrJJRNaIyGoRWeVtaxOR+0TkNe/31lqvs1YWXXY3LrttTa2XQUREVFUsiJVRqODjb0uZdt79bpxh8cjEQjPEAOD4RdNw0D4teOuCqV6HmF1wPz8ysSdloilhQApczRPTBf0ZryBWJDIRcLvHGuLRdba31CFl2kiZtjfDrFyHWPnIRP8+y3ZghSITASCmuUXEQnb1pQGwQ4yIiIiIiIiIhuQkpdRSpdQy7/YlAB5QSi0C8IB3e69105Oba70EIiKiqmJBrIzojCyvIOYVfpSKdpDFdXeGWO+AWbRDLF4gMhEArjzrYNzy2beiqc5Af4kOMb9A1tGfKRrLGNM1JNPeDLEiXVv+sXMjE/15Ht0pE2nTLjtDLFZBZCIANCYMdKdMmHZ07prhFcoKYYcYERHRxHSYFxdNREREVGVnAfi19/OvAby7FotYv6sPG3f31+LUAICuZKZm5yYiIqolzhAro9CMrEhBJ1Lc0aAU0JU00ZQoNkPMLUDlRhHqmkDXdDTGdfSnozPEoo93H7enL1O86OZ1qgH5BbWwz5+yCPu3N0e2+TPJelIWBswKZoiFC4YlzjVzUh2296SRsVWkcGZoAssp3CG2x+sQm8oOMSIionGtd8CM3L7qrINrtBIiIiLaiygAfxERBeCnSqnrAbQrpbZ5928H0F7ogSKyEsBKAJg7d+6IL2zFDx4GAGy65owRP3YlPnfTszU5LxERUa2xIFZGtENMIr/n/+zum7acCjrEChePGuKGG1mYsSP75z5+d38a05sLF4rCjynVtfXhY+blbYt0iFlO2Q6xSMFQKx6ZOGNSHTbu7odSQDwUmWh4s8UK2dOfQV1MQ0O8dFGOiIiIxrZ1O/sitw+ZPalGKyEiIqK9yHFKqa0iMh3AfSLycvhOpZTyimV5vOLZ9QCwbNmywlfxjmO7etO1XgIREVFNMDKxjIIdYnrhDrFwcWywkYk+f/ZYV8r09sspiOnZyMRiXWgxvbKCWCHhgtiAaaMuVroYVWlk4sxJ9djWPZAfmagJ7CIdYrt705jSmCg4J42IiIjGj2L/ryciIiIaLUqprd7vOwHcCmA5gB0iMhMAvN931m6F1XfjE29g3iV34uXtvbVeChERUU2wIFZGoYJPuBMqMkMsVLwqVhBLlOsQS7gFqM7+TN4xw7e7kiZaipwjWhAbXDGppd49Zo/XIVZsnb7ceWDFzJhUh94BC10pM69gZ9pFCmL9Gc4PIyIimgBYECMiIqJqEpFGEWn2fwbwdgBrAdwO4EJvtwsB/LkW65s/tRGzW+urft6v37qm6uckIiIaSxiZWIYeKvj4UX9GkQ6s8M/Furca4jpiumByQ+H7G+Puf5IOryCW1yFWQdEtZhQu0lXC7xDr6M/ActSIdYjNaKkD4Bbywo8xdIHlFIlM7EsHjyMiIqLxiwUxIiIiqrJ2ALd6iTMGgBuVUveIyFMAfi8iHwfwOoD31WJxsybXI2XaVTtfKmPjPx54rWrnIyIiGqtYECsj0g2m+ZGJ4W2FC0LFilUNcQO3fOZYLJzeVPD+Ri8ysTNZpEMsco7CRbVEaJ/4ICMT/WPu7B1wjzWIDrGSBbFJdQX3MzSBVaRDbE9fBgft01J+0URERDTmJDMWvn/vq/jqafvDVtn/19/xueNquCoiIiLaGyilNgA4rMD2PQBWVH9FUet29mF7z0DVzvel36/G3Wu3V+18REREYxULYmUU6gaLFYkJDHc+NRUpiAGlB8k3xt2OrGyHWLRDK1wgK3aO4cwQ0zVBc8LATm/AarkOMd17zpq4jy1mZqggFi0oajDt/A4xpRT29KcxpSkxqPUTERHR2PDThzfgF49uxLTmBPafkb0QaNbk6scDEREREY0lu/vSVT3fs290VfV8REREY9WwZoiJyLki8oKIOCKyLLR9noikRGS19+t/QvcdISJrRGSdiPxYvP51EWkTkftE5DXv99bhrG2khIs8fmSiXqBrDIh2YxWb71VOg9ch1pU0AQw1MnHoBTEAaKmPYWdPuuD5887lPf9y52kPRR+GXyc3MjG/Q6wnZcG0FaY0coYYERHReORHIr+0rQd3PLct2N7K/7cTERHRXm7FAdOxf3vzqJ+nL23hwZd3QoHx1URERMAwC2JwB5K+B8AjBe5br5Ra6v36dGj7dQA+CWCR9+s0b/slAB5QSi0C8IB3u+Zien7xK3cGVnbf8jPEymlK5HaIRf8TJYzykYnhdQx2hhjgzhHzIxPLdYj5z79cNGNdTEeb9wVYJDJR1yIFMaUUbn/uTazf3QcAmNbMDjEiIprYROQ0EXnFu1go7/2PiCRE5Gbv/idEZJ63/VQRedq70OhpETm52muvxO3PvYlbnt1a62UQERERjRkCqUqR6it/eA4f/dVT2NFT3Y40IiKisWpYkYlKqZcAwGvyKktEZgJoUUo97t3+XwDvBnA3gLMAvM3b9dcAHgLwteGsbySEu8H8zisRga4JbEcVjU8s1r1VTkO89AyxcIRisXOEHzPYGWIA0FJv4IWtSe98ZTrEvOccfu7FzGipQ0d/JlpE1ARWKDJx/a5+/PNNzwYddlMaWRAjIqKJS0R0AP8F4FQAWwA8JSK3K6VeDO32cQCdSqmFInIegO8BeD+A3QD+SSn1pogcDOBeALOq+wyIiIiIaLA0DVBVaNrauLt/9E9CREQ0jgy3Q6yU+SLyrIg8LCLHe9tmwf2yx7cF2S9u2pVSfp7OdgDto7i2ikXncYW7xfILQX7xSROgIV66s6qYRq8gVskMseZEkYJYuOBkVFasDJtUH0Nv2gJQQYdYhZGJQHaOWCw3MtHOvgv0c7T7MzYAYEoTY5WIiGhCWw5gnVJqg1IqA+B3cC8SCjsL7sVCAPBHACtERJRSzyql3vS2vwCgXkTG9JUk73kL63VEREREAoFTjYoYERERRZRtYxKR+wHMKHDXZUqpPxd52DYAc5VSe0TkCAC3ichBlS5KKaVEpOg7AxFZCWAlAMydO7fSww6JoeUXvAC3qJO2nGjBzCtWNSWMirvmcjV4kYnFOsTCa6gkMnEoM8Qm1WePW65DzC8IVnKeGUFBLBoz2WdZwe1OrxD4k/MPxys7erG4CpnaRERENTQLwObQ7S0Ajiq2j1LKEpFuAFPgdoj5zgHwjFJqTOfhfO+cQ2u9BCIiIqLaE1RlqtfuvkwVzkJERDR+lC2IKaVOGexBvS9j0t7PT4vIegCLAWwFMDu062xvGwDsEJGZSqltXrTizhLHvx7A9QCwbNmyUX0PYWjReVfZn70OMS1/hlixQlUlYrqGuKEhYzkwNIlENgI5HWJFIhOHWxBrCa0/UaZDzD9+rILIxEIdYroW7RDr8AqBh89txemHzKx80URERHsp76Kj7wF4e4l9qnYxka/QRc9DeV9CRERENNEIUJWKmJ/CQ0RERK5R+VZCRKZ5MzEgIvsBWARggxeJ2CMiR4vbQvVhAH6X2e0ALvR+vjC0vaYi864ikYnuS6cXuH+o88N8jV7cYm53WO62SmaIlevwKiTcIVYXK9Mhpg2mQ6w+b19D02CGZoh1JU0AwOSGoRcViYiIxpGtAOaEbocvFsrbR0QMAJMA7PFuzwZwK4APK6XWFzuJUup6pdQypdSyadOmjeDyiYiIiGiwNJGqdIgRERFR1LAKYiJytohsAXAMgDtF5F7vrhMAPC8iq+HOuvi0UqrDu++zAH4OYB2A9QDu9rZfA+BUEXkNwCne7ZqLFMS0cOeV5G3z4wybisz2qlSj9/hCxSy/2CWSnTeWt89wIxMbwpGJlXWIGYOaIRYtItpOqEOsP4OGuF52dhkREdEE8RSARSIyX0TiAM6De5FQWPiiofcC+KsXLz0ZwJ0ALlFKPVq1FVdoiOnRRERERBOeCDhDjIiIqAaGVblRSt0K96rk3O1/AvCnIo9ZBeDgAtv3AFgxnPWMBr8TzNAEWii+MIhM1PMjE5uG3SHmPr5gh5h/jrgRWU+Yvw5NkBe5WIlwZGLZDjHv+ccriEyc29YAINqBZugarFBBrLM/g9aG+KDWS0RENF55M8EuBnAvAB3AL5RSL4jItwGsUkrdDuAGAL8RkXUAOuAWzQDgYgALAVwhIld4296ulCoaO01EREREtScoHC9NREREo2t4lZu9QKHCF5AtlEXmdRnDnyEGAA0JtzuqUHdWPJhTVvw/XdC9NsQ5HeGCVbkOsUKvQzFz2hrwfxcfhwNmNgfbYppEIhM7kxm0NbIgRkREew+l1F0A7srZdkXo5wEA5xZ43FUArhr1BRIRERHRiBIRqFEKTfzLC9ux8jdP4/FLx9w150RERDXHglgZsSIFH392lqGFIxXdn4cbmeg/vlCHmKYJYrqULLr5hblCj69ES312/ZXOEMstGBZzyOxJkdu6JrDsUGRi0uT8MCIiognor18+sdZLICIiIhoTREavQ2zlb54GALy4rXt0TkBERDSODWuG2N7AjxyM5xbECszO8otmLcOMTGyI+x1ihf/zxHWtZCyjv9bcNVdqUB1iw+xGcyMTQx1i/ewQIyIimoj2m9ZU6yUQERERjQkCGfXIxNWbWRAjIiLKxYJYGbEikYnZWMLsdr8ja7gdYo0lOsQAIBHTS0Ym+o8bapGqxSuIaRJ9foX45xjquWK6wAx1iHUmOUOMiIhoItjZk671EoiIiIjGJLdDbHQrYj9+4LVRPT4REdF4xMjEMkQEuiYlIhOz2xsTBr75TwdixQHtwzpnY9z9z1KqQ6xkZKJfpDIqizHM1eIdO2HoECl9DP91KFc4K/54Dbbjvgk0bQe9AxYLYkREROPcqzt68Yent9R6GURERERjkgCjNEGMiIiISmFBrAK6JsUjE7VoIegjx84f9vkaEm5MYbxIXOFFJy0oGTsUG2aMYV1MR8LQys4PA7KRksPrEHMjEzuTGQBAWyNniBEREY1nG3f313oJRERERGOWJqMfmUhERET5WBCrQKxAh1ixKMWR0FSmQ+xDx8wr+Xg/MnGoM8QAd46YrpV/biKCmJ7/+lTK0AWW1yHWlTQBAK2cIUZERDShvOuwfWq9BCIiIqIxQwRwWBEjIiKqOhbEKqBrklf48qMSjWEUnYppKDNDrBy/EDbUxwPuHDHL69wqx9C0IUcm6l5kolIKHf1ehxgjE4mIiMa1G/62MXJ75Qn71WglRERERGOPCCMTiYiIamHkqzkTUEzXinaIxSroohqsxrgblVisQ6ycYIbYMDvE6mKFIxtzGcPoEPNfP9NW6PQKYpNZECMiIhrXnt3cGbl98KxJNVoJERER0VjEyEQiIqJaYIdYBQw9f4aYHyc4Gh1ijYnSkYnlZAtiQy/WLZreFHRslXPqge1YPr9tSOfxXz/bUej0IhPbGJlIREQ0rhmaBtO2a70MIiIiojFJBGCPGBERUfWxIFYBQ9MQM3IiE3U/MnEUOsQSfodYZR1aufxCWHyIjweA75x9SMX7/vB9S4d8Hn+tpuOgM+l3iMWGfDwiIiKqvZTJYhgRERFRMZoADuthREREVceCWAUMXYKZYT4/6i+mjcIMsfjwZoiJuB1t8WEU67RRiIIsxPDOY9nuDLGGuF5xVCMRERERERER0XgjEChmJhIREVUdZ4hVwNDyZ2T5HWL6KBSOmoYZmQi4nVfDmSFWLf7raNluh1gr54cRERFNKH/54gm1XgIRERHtZURkjog8KCIvisgLIvJ5b/s3RWSriKz2fr2zNutjYCIREVEtsEOsAm+Z24q5bQ2RbX7U33DmdBXTEHc7pHLnlg1GzNDGR0FM8yMTFTr7M5wfRkRENMEsbm+u9RKIiIho72MB+LJS6hkRaQbwtIjc5913rVLq+zVcGwQAG8SIiGhv5Nc+aoUFsQr8+7mH5W3zIxSNUSg6NfodYrHhdIiNk4JYqEOsI2lyfhgRERERERERDYtSahuAbd7PvSLyEoBZtV1VlggjE4mIaO/0joNm1PT8Y79iMkYZXmeYMQqRiW2Ncbxl7mQcPGvSkI/xuZMX4pwjxsx7vaL8DjvLUehKskOMiIhovPr1PzbhyY0dtV4GERERUYSIzANwOIAnvE0Xi8jzIvILEWmtzZpGvkPs8Q178Ment4zsQYmIiEbYyFdTBocdYkPkd1+NRhdWTNdwy2ePHdYxPnzMvJFZzCjzO+0sW6GjnzPEiIiIxqt/vf0FAMCma86o8UqIiIiIXCLSBOBPAL6glOoRkesAXAl3hNeVAH4A4GMFHrcSwEoAmDt37sivCzKiM8SSGQvnXf/4CB6RiIhoYmKH2BD5nWHGKMwQ25v4r1/GctCXttBSxxotERHRRMHObyIiIqoVEYnBLYb9Vil1CwAopXYopWyllAPgZwCWF3qsUup6pdQypdSyadOmjcLaMKKRif1pe8SORURENKpqXE5hQWyI/IJYTONLOBz+69idMqEU0FzHGWJEREQTxYP/8rZaL4GIiIj2QiIiAG4A8JJS6oeh7TNDu50NYG211wYAmmBEO8Q4j4yIiKgybMcZIsOLStTZITYs/uvYkcwAAJrZIUZERDSuZSwn+HlSPS90ISIiopo4FsCHAKwRkdXetq8DOF9ElsKtR20C8KlaLO7/t3fnYXJVdcLHv7+u7iQdIBt7EiQBIrKFLbIoIgJCWDSiIHFQUZlBHX30fX3nRXhBFEdUnFeReQdFRlF0VFAchEEQQWAAlSVAgAQIdNgSCCRk3zvdfd4/6naoJN2dXqq76lZ/P89zn7517q2q3zn35N6TOvecGxG0lbETq83+MEmSusXeh15qn+qvoc4Osb5oL7+lq9s7xPzhTJKkPHvrRbdVOgRJkjTIpZTup+NJmW4d6Fg6EkC5+sNeXrzGm7UlSeomO8R6qX2qxPYRTuqdjSPEVjtCTJIkSZIkDQJlmjJx1ivLOfX/3c/x++xUhk+TJKn/RYUfImZvTi8dvscYTpm8q1MB9VH7SLtlTpkoSZIkSZIGgbooT4/YS4vXAHDn0wv7/mGSJA2AqPCgZnsfemny+FFc+XeHVDqM3GsfabdkzQbAKRMlSaoVl595YKVDkCRJqkoBZX2GmCRJ6p4+jRCLiDMiYnZEtEXElJL0syJiZsnSlj20lIi4JyLmlGzbKUsfGhHXR0RTRDwYERP6EpvyoVC36QixEY4QkySpJpx28PhKhyBJklSVyjRAjFSWT5EkafDo65SJs4APAveWJqaUfplSOiildBDwMeCFlNLMkl3Oat+eUmof130OsDSltBdwOXBZH2NTDjRkUya++QwxR4hJkiRJkqTaFQTJEWKSpEHo9lmvVfT7+9QhllJ6OqU0Zyu7fQS4rhsfNw24Nlu/ATguotIzSqq/1ReKVXDp6mbq64JhDT7WTpIkSZIk1a66MowQW9vcyud/9Vi88FppAAAZJElEQVRZ4pEkaaCsXN9S0e8fiN6HM4Ffb5b202y6xK+UdHqNA+YBpJRagOXA9gMQnyqoPpsyccmaZrYbVo99oJIk5d8+u46odAiSJEnVK4K+DhDb5+I/licWSZIGka12iEXEnRExq4NlWjfeeziwJqU0qyT5rJTSAcC7suVjPQ06Is6NiBkRMWPRokU9fbuqSEM2QmzdhjanS5QkqUb86u8Pr3QIkiRJVav9VuDeTpvY1uZ0i5Ik9Ub91nZIKR3fh8+fzmajw1JKr2R/V0bEr4DDgJ8DrwC7AfMjoh4YCSzuJKargasBpkyZYisgxwp1b44I227YVqujJEnKgdHbDKl0CJIkSVWrfXKclN5c747nF61iTXMr85eu6Z/AJEmqcf3WAxERdcCHKY4Ca0+rB0allN6IiAbgVODObPPNwNnA34DTgbuSTxiteQ0FO8QkScq7B57v8B4mSZIkdSCyMWI9/dHr2O/+d/mDkSRpEOnTM8Qi4rSImA8cCfwhIm4v2Xw0MC+l9HxJ2lDg9oh4AphJcVTYv2fbfgJsHxFNwJeA8/sSm/KhvvBmFXTKREmS8um5has2ro8a7vVckiSpKz++r/hT2esr1lU4EkmSBpc+DclJKd0I3NjJtnuAIzZLWw0c2sn+64Az+hKP8qfeKRMlScq90pl+/nb+cRWLQ5IkKQ9Wrm8BYMHytYwd1VjhaCRJGjz6NEJM6quGkhFiIxwhJklSLpU++6JxSKFygUiSJOVITx4U4lNFJEnqOzvEVFGFutj4I5ojxCRJkiRJ0mDR1oM+rkdfXtZ/gUiSNEjYIaaKa5820Q4xSZLyqXQKZEmSJHVP9KAJ1dLa1n+BSJI0SNghpoqrrytWw+2cMlGSpFwa2Vi8hl/10Q4fFStJkqQSl33oAACG1Xdvqunlazdw5tUP9GdIkiQNCnaIqeLqC44QkyQpz9pvWJ64wzaVDUSSJCkHthla/P3j6ddWdGv//3n9zP4MR5KkQcMOMVVcQ8ERYpIk5Vlr9pD3gi1LSZKkrarL5kr87zmLtrpvSom7nlnY3yFJkjQoOCRHFeczxCRJyrdfPvASAIU6e8QkSZK2Zk1zKwB/eHIBV3ayz4mX30sEvO/AsQMXmCRJNc5fLVRxG0eIDbVDTJKkPJo5bxkAhZ48GV6SJGmQ2m/siK3uM+f1lTzz2kr+5fY5AxBRdfjxx6dUOgRJUo2zQ0wVV9g4QswpEyVJyqOU/S0U7BCTJEnaGp+72rFtqvRG6Z1HDK10CJKkMrFDTBVXX3DKREmSci3rEXOEmCRJ0tYNayh0uX3dhtYBiqRjb58wus+fMWH74dz2xXdtfP2OPbffuH7RKft0+J4j9hjT5+/tzDdPO4BxoxqBNx/d0e7MKbttXJ9x0fHMvPi9vPjtU5h2UHG6ygf/z/G88K2T+c2nj2TGRcez25hGdt9+OO+atEOPYrjqo4cCcNReHb9vzDZDevR5kqSeswdCFddQV0ehLhg+pOsGoSRJqk4p6xEr1NkhJkmS1F2jhm85U87dcxbyyZ8+XIFo3nTtpw5j34tv79F7fvfZd3DeDY8zd9Fq/uvzRzFhh+FsN6yBF799CgBLVjdzyD/fAcA5R01kaEOBptdXMnP+ch6ft4wfnHUIEcGsS07kh/c0ceXdc/nq+/blr3MXc8dTr/PrfziC/ceN4Ks3zWbFuha+c/pk/jT7Nc7/zyd55p+nsnh1M8vXbGDsqGGsb2mjpS0xblQjC1esY2h9gZHDG/i7w9/CsjXNjGxsIDa7keuy0ydvkacrph/MFdMPBiAiOGxiscPuvvOOBSClxOV3PMuEHbbhsIljaG1L3PfcG1z0+1l87j17cvaRE5i9YAV77rAthUIwblQjfz3/WMaOauTB5xfz0uI17D9uJHvttC0tbW00NhSYu2g1ry5byxV/fo7LPjSZpoUr+cx/PArAnV96NxN32Ibv3TGHK++euzHOqfvtwnlT92bluhYOGDeSFes2MHfRKq74cxPfPeNAbp/9Ghf9fhYjhtVz8gG78tlj9uSY/3sP3z/zIJ5esJKr751LW6JDn3znBH76lxc3vv7icZO44s/P9ahuSFKpSt9HGyl1csbLiSlTpqQZM2ZUOgz1wSn/eh/zl67l8a+eUOlQJEn9JCIeSSn5UIAq0B9tp0kX3sqG1sSjX3mvd7ZKklQGtp36T0RMBa4ACsCPU0rf7mr//vrd6cwf/Y22lPjtZ96xMW3ZmmYO+vodZf+unnrx26cw4fw/bJJWqAtOnbwrN818FYBTJ+/KLU8sAGD2JSd2a7rDP856jfGjG9l/3MhN0ptb2hhSXzuTWDW3tNFQiC063Xpr3pI1jB3VOCA3ny1Z3UxjQ4FhDXWbxP/a8nXsMnIYAE0LV3HLE6/yxeMmcfFNs/nce/ZiRGM9j760jMMmjiGRGFIovr9p4Sq+evMsmlva+O1n3kFzSxvXP/wy85et5csnvo2V61oAWLa2mV1GDmNDa6ItJRavambpmmYuunEWTy1YwWkHj+N/nfBWTrj8Xv7+qImcfuhu/OCeJq57eB6XvH8/9t5lO6Zf/QD3nfcehtTX0TikwFX3zOULx02ivi5obm3j3mffYN6SNRz91h254ZF5/H7mqyxauR4ojhr8zLv35C9z3+Cxl5dtUib/dMJbeXX5OqbsPpo7n36dW598bZPtjQ0F1paM6hw1vIFlazZsUbafeudErvnLC+U5UCX+94l789HDd+d3j87n67c8tdX9Rw9vYGlJfPuPG8GsV1b0OY76uqClLTF1v1344+zXtv6GzRw2cQwPvbCkz3Go+n3w4HF878yDyv653W072SGmipt25V9YvGo993/52EqHIknqJ/6oUz36o+3U/oPJY195L6PtEJMkqc9sO/WPiCgAzwLvBeYDDwMfSSl1+ityf/3u9KXrZ/LH2a/x1NenklLizKsfqJofg1/89ilcfNMsfv63lwD49Lv34IKTitMcfu+OZ/nYEbuz43Y+V0u1bfnaDdTXRb8+266jzs7mljbqAl5cvJqxoxoZPmTT729rS7SmxLOvr6Qugn12HdGt72puaePBFxbzrkk7bvyc5tY2hjUUaG1LBLC6uYW2BCMbtxy9WmrdhlaWr93AziOGsXDlOlrbEruObNy4/ekFK1i6ppmFK9Yzdf9dGNZQYH1LK6vWtbD9tkN5efEamlvb2Gunbbf47FXrW9hmSGGLDuWW1jY2tCaeeW0FrW2J1c2t7LHDNowd1chtsxZwwr670JoNdRxaX8cbq9ezoTUxsrGBbUuO4eJV62lLbDyH/fi+5zlwt1G8fcIY1ja38vCLS9hzp20ZN6qRNc0t3Pn0Qt62y3a8vHgN37ztab4xbX92GzOcd33nboYU6pg8fiQfPGQ86za0cvqU8dz9zEL2GzuSCdsP576mN3jpjdVEBDPnLeP4fXZm/tI1vOdtO/GJax7ikmn7c8zeO/LS4tUsWL6OXUc2snztBm54ZD6nHTyOD//ob+wyYhjf+uABHLP3jryxqpm3X3onV330EL5y02wWrVzPN087gJGNDYxorGdDaxuf+tkMzj16D3YdOYwlq5t5ftFqoHhTw82PF29o+PTRe7DbmOFc9PtZm5TxD886hL/OXcwvHiie+w/dfTSPvryUlGCvnbZlyu6jue7heQB89pg9WbBsLb+f+Sp77rgNcxet5sg9tmfU8AbqIvjDkws2+ezTDh7HjY+9wrCGOmZfMrVfOvjtEFNufOiHf2VNc+smc0tLkmqLP+pUj/7sEGu69CTqC7Vzd68kSZVi26l/RMSRwNdSSidmry8ASCl9q7P39NfvTp/46UPcM2dRWT7rRx87lE//4pEt0vcbO4KrPnooo4Y3cMDX/rQx/R+P2ZPdxgzn7mcWcvy+O3P/c2/w/TMP4if3v8Co4Q2ckT1T6+kFKxjR2LDx2VuSpNrT3NLGS4tXM2nn7SodSp90t+3kM8RUcTuPGLqxB1+SpMFma9P2RMRQ4OfAocBi4MyU0ovZtguAc4BW4AsppZ497KFM3nfgWP7r8VftDJMkSdVuHDCv5PV84PBKBPKd0ydz2KV/7tNn7LXTtlx4yj68Z++duPUL7+L+pkWcMnls9iyqVbx9wpiN+7Y/y6vURw57CwAfzjrA/uHoPTbZ3t2RJ5Kk/BpSX5f7zrCesENMFffdMw4iYYeYJGnwyabtuZKSaXsi4ubNpu05B1iaUtorIqYDlwFnRsS+wHRgP2AscGdEvDWl1MoA+96HD+QbH9h/oL9WkiSpX0TEucC5AG95y1v65Tt22m7YFp1U61taWbyqmSWrm3nbLttRqAtSgrpuTC2179gR7Dv2zQ6sMduM6WJvSZIGJ2/jVcU1DilsMR+uJEmDxGFAU0rp+ZRSM3AdMG2zfaYB12brNwDHRXFC9WnAdSml9SmlF4Cm7PMGXEOhbqvzzEuSJFWBV4DdSl6Pz9I2kVK6OqU0JaU0Zccddxyw4IbWFxg7qpH9x42kvlBHRHSrM0ySJHWPHWKSJEmV09G0PeM62yel1AIsB7bv5nuB4l3OETEjImYsWlSeZ1VIkiTl0MPApIiYGBFDKI62v7nCMUmSpAFih5gkSVKNq9RdzpIkSdUku7no88DtwNPAb1JKsysblSRJGijOUydJklQ53Zm2p32f+RFRD4wEFnfzvZIkSSqRUroVuLXScUiSpIHnCDFJkqTK6c60PTcDZ2frpwN3pZRSlj49IoZGxERgEvDQAMUtSZIkSZKUK44QkyRJqpCUUktEtE/bUwCuSSnNjoivAzNSSjcDPwF+ERFNwBKKnWZk+/0GeApoAT6XUmqtSEYkSZIkSZKqnB1ikiRJFdTRtD0ppYtL1tcBZ3Ty3kuBS/s1QEmSJEmSpBrQ5ykTI+JfIuKZiHgiIm6MiFEl2y6IiKaImBMRJ5akT83SmiLi/JL0iRHxYJZ+fTZ1kCRJkiRJkiRJktRr5XiG2B3A/imlycCzwAUAEbEvxSl99gOmAj+IiEJEFIArgZOAfYGPZPsCXAZcnlLaC1gKnFOG+CRJkiRJkiRJkjSI9blDLKX0p5RSS/byAWB8tj4NuC6ltD6l9ALQBByWLU0ppedTSs3AdcC0iAjgWOCG7P3XAh/oa3ySJEmSJEmSJEka3MoxQqzUp4DbsvVxwLySbfOztM7StweWlXSutadLkiRJkiRJkiRJvVbfnZ0i4k5glw42XZhSuinb50KgBfhl+cLrNJ5zgXOzl6siYk4/fM0OwBv98LnalOU8MCzngWE5DwzLeWCUu5x3L+NnqQ8eeeSRNyLipX746Fr/t2n+8s385Zv5yzfz1zu2naqEbadeM3/5Zv7yzfzlm/nrnW61nbrVIZZSOr6r7RHxCeBU4LiUUsqSXwF2K9ltfJZGJ+mLgVERUZ+NEivdf/N4rgau7k7svRURM1JKU/rzO2Q5DxTLeWBYzgPDch4YlnPtSint2B+fW+t1xvzlm/nLN/OXb+ZPeWfbqXfMX76Zv3wzf/lm/vpXn6dMjIipwHnA+1NKa0o23QxMj4ihETERmAQ8BDwMTIqIiRExBJgO3Jx1pN0NnJ69/2zgpr7GJ0mSJEmSJEmSpMGtWyPEtuLfgKHAHREB8EBK6TMppdkR8RvgKYpTKX4updQKEBGfB24HCsA1KaXZ2Wd9GbguIr4BPAb8pAzxSZIkSZIkSZIkaRDrc4dYSmmvLrZdClzaQfqtwK0dpD8PHNbXmMqkX6dk1EaW88CwnAeG5TwwLOeBYTmrp2q9zpi/fDN/+Wb+8s38SR2r9bpj/vLN/OWb+cs389eP4s1HfkmSJEmSJEmSJEm1p8/PEJMkSZIkSZIkSZKqmR1iHYiIqRExJyKaIuL8SsdTSyLixYh4MiJmRsSMLG1MRNwREc9lf0dXOs68iYhrImJhRMwqSeuwXKPoX7P6/UREHFK5yPOlk3L+WkS8ktXpmRFxcsm2C7JynhMRJ1Ym6nyJiN0i4u6IeCoiZkfEF7N063MZdVHO1mf1Sl7bTj1pl3R1vomIs7P9n4uIsyuYn7K0BzrLT0QcmpVXU/beqIL89fi81Vl9jYiJEfFgln59RAwZuNyV9xpYjcewnNeeajyGETEsIh6KiMez/F3SVUwRMTR73ZRtn9DbfFc4fz+LiBdKjt9BWXqu6mdJDIWIeCwibsle18TxU3XJc10I2065Oq91kr+auO5m32/bKcfHMGw75b7tFHltN6WUXEoWoADMBfYAhgCPA/tWOq5aWYAXgR02S/sOcH62fj5wWaXjzNsCHA0cAszaWrkCJwO3AQEcATxY6fjzsnRSzl8D/qmDfffNzh9DgYnZeaVQ6TxU+wLsChySrW8HPJuVpfV5YMrZ+uzS4yXPbaeetEs6O98AY4Dns7+js/XRFcpPn9sDXeUHeCjbN7L3nlQF+evReaur+gr8BpierV8FfHaA81eWa2C1HsMu8lcTxzAr022z9QbgwaysO4wJ+Efgqmx9OnB9b/Nd4fz9DDi9g/1zVT9L4v4S8Cvglq7qVN6On0v1LHmvC9h2ytV5rZP8fY0auO5m32nbKcfHENtOm++fq/qZfX8u202OENvSYUBTSun5lFIzcB0wrcIx1bppwLXZ+rXAByoYSy6llO4FlmyW3Fm5TgN+nooeAEZFxK4DE2m+dVLOnZkGXJdSWp9SegFoonh+URdSSgtSSo9m6yuBp4FxWJ/Lqoty7oz1WV2ptbZTT883JwJ3pJSWpJSWAncAUwc6aChbe6DD/GTbRqSUHkjF/738nAFus5XpOtxhfc3upjwWuCF7/4C3Sct4DazKY1jGa09VHsPsOKzKXjZkS+oiptLjegNwXJaHHuW7n7O1URf560yu6idARIwHTgF+nL3uqk7l6vipqtRiXbDtVKXnNdtOW8SVq2No22mLmHJ17a31tlOe2012iG1pHDCv5PV8uj7ZqGcS8KeIeCQizs3Sdk4pLcjWXwN2rkxoNaezcrWOl9/ns+HM18SbU35azn2UDaE+mOJdNNbnfrJZOYP1WT2X5/rRk3ZJZ/ms9vyXKz/jsvXN06tBT85bnaVvDyxLKbVsll4RfbwGVv0x7OO1p2qPYTZtzExgIcUfK+Z2EdPGfGTbl1PMQ9WeazbPX0qp/fhdmh2/yyNiaJaWx/r5feA8oC173VWdyt3xU9XIe12w7fSmPJzXOlMT191Stp2AHB5D2065bjvltt1kh5gG2lEppUOAk4DPRcTRpRuzHu2uesvVC5Zrv/ohsCdwELAA+G5lw6kNEbEt8Dvgf6SUVpRusz6XTwflbH3WYDOo2iW1lp9MzZ23av0aWMvXnpRSa0rpIGA8xTtb31bhkMpq8/xFxP7ABRTz+XaKU/l8uYIh9lpEnAosTCk9UulYpCpn2yn/aua62862U36PoW2nfLad8t5uskNsS68Au5W8Hp+lqQxSSq9kfxcCN1I82b3ePsVZ9ndh5SKsKZ2Vq3W8jFJKr2cXuDbg33lzGjnLuZciooFiY++XKaX/zJKtz2XWUTlbn9VLua0fPWyXdJbPas9/ufLzSra+eXpF9eK81Vn6YorTktRvlj6gynQNrNpjWKZrT1UfQ4CU0jLgbuDILmLamI9s+0iKeaj6c01J/qZm0zmllNJ64Kf0/vhVun6+E3h/RLxIcVqeY4ErqMHjp4rLdV2w7ZSr81qHau26a9sp/8cQbDtlu+Wpfua63WSH2JYeBiZFxMSIGELxQW83VzimmhAR20TEdu3rwAnALIrle3a229nATZWJsOZ0Vq43Ax+PoiOA5SVDydVD7Y2szGkU6zQUy3l6RAyNiInAJIoPu1QXsjmEfwI8nVL6Xskm63MZdVbO1mf1Ui7bTr1ol3R2vrkdOCEiRmfTlZyQpVWLsuQn27YiIo7IziEfpwrabL04b3VYX7O7h+8GTs/eP+Bt0jJeA6vyGJbx2lOVxzAidoyIUdl6I/Beis/66Cym0uN6OnBXloce5bv/c1bUSf6eKfnBMSg+J6L0+OWmfqaULkgpjU8pTaBYtnellM6iRo6fqkpu64Jtp3yd1zpTK9ddsO2Uye0xtO2U37ZT7ttNKSWXzRbgZOBZivOWXljpeGplAfYAHs+W2e1lS3HO0D8DzwF3AmMqHWveFuDXFIdJb6A4r+o5nZUrEMCVWf1+EphS6fjzsnRSzr/IyvGJ7OS8a8n+F2blPAc4qdLx52EBjqI4ncETwMxsOdn6PGDlbH126dWSx7ZTT9slXZ1vgE9RfABwE/DJCuapLO2BzvIDTKH4H7a5wL8BUQX56/F5q7P6mtWJh7J8/xYYOsD5K9s1sBqPYRf5q4ljCEwGHsvyMQu4uKuYgGHZ66Zs+x69zXeF83dXdvxmAf8BbJvH+rlZXo8Bbqml4+dSXUte6wK2nXJ3XuskfzVx3c2+37ZTjo8htp1qou1EDttNkX2BJEmSJEmSJEmSVJOcMlGSJEmSJEmSJEk1zQ4xSZIkSZIkSZIk1TQ7xCRJkiRJkiRJklTT7BCTJEmSJEmSJElSTbNDTJIkSZIkSZIkSTXNDjFJkiRJkiRJkiTVNDvEJEmSJEmSJEmSVNPsEJMkSZIkSZIkSVJN+/8z5jK24TRkwQAAAABJRU5ErkJggg==\n",
      "text/plain": [
       "<Figure size 2160x360 with 3 Axes>"
      ]
     },
     "metadata": {
      "needs_background": "light"
     },
     "output_type": "display_data"
    }
   ],
   "source": [
    "agent.train(num_frames)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## Test\n",
    "Run the trained agent (1 episode)."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 13,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "score:  -129.5194992689775\n"
     ]
    }
   ],
   "source": [
    "# test\n",
    "if IN_COLAB:\n",
    "    agent.env = gym.wrappers.Monitor(agent.env, \"videos\", force=True)\n",
    "frames = agent.test()"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## Render"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 14,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/html": [
       "\n",
       "<script language=\"javascript\">\n",
       "  /* Define the Animation class */\n",
       "  function Animation(frames, img_id, slider_id, interval, loop_select_id){\n",
       "    this.img_id = img_id;\n",
       "    this.slider_id = slider_id;\n",
       "    this.loop_select_id = loop_select_id;\n",
       "    this.interval = interval;\n",
       "    this.current_frame = 0;\n",
       "    this.direction = 0;\n",
       "    this.timer = null;\n",
       "    this.frames = new Array(frames.length);\n",
       "\n",
       "    for (var i=0; i<frames.length; i++)\n",
       "    {\n",
       "     this.frames[i] = new Image();\n",
       "     this.frames[i].src = frames[i];\n",
       "    }\n",
       "    document.getElementById(this.slider_id).max = this.frames.length - 1;\n",
       "    this.set_frame(this.current_frame);\n",
       "  }\n",
       "\n",
       "  Animation.prototype.get_loop_state = function(){\n",
       "    var button_group = document[this.loop_select_id].state;\n",
       "    for (var i = 0; i < button_group.length; i++) {\n",
       "        var button = button_group[i];\n",
       "        if (button.checked) {\n",
       "            return button.value;\n",
       "        }\n",
       "    }\n",
       "    return undefined;\n",
       "  }\n",
       "\n",
       "  Animation.prototype.set_frame = function(frame){\n",
       "    this.current_frame = frame;\n",
       "    document.getElementById(this.img_id).src = this.frames[this.current_frame].src;\n",
       "    document.getElementById(this.slider_id).value = this.current_frame;\n",
       "  }\n",
       "\n",
       "  Animation.prototype.next_frame = function()\n",
       "  {\n",
       "    this.set_frame(Math.min(this.frames.length - 1, this.current_frame + 1));\n",
       "  }\n",
       "\n",
       "  Animation.prototype.previous_frame = function()\n",
       "  {\n",
       "    this.set_frame(Math.max(0, this.current_frame - 1));\n",
       "  }\n",
       "\n",
       "  Animation.prototype.first_frame = function()\n",
       "  {\n",
       "    this.set_frame(0);\n",
       "  }\n",
       "\n",
       "  Animation.prototype.last_frame = function()\n",
       "  {\n",
       "    this.set_frame(this.frames.length - 1);\n",
       "  }\n",
       "\n",
       "  Animation.prototype.slower = function()\n",
       "  {\n",
       "    this.interval /= 0.7;\n",
       "    if(this.direction > 0){this.play_animation();}\n",
       "    else if(this.direction < 0){this.reverse_animation();}\n",
       "  }\n",
       "\n",
       "  Animation.prototype.faster = function()\n",
       "  {\n",
       "    this.interval *= 0.7;\n",
       "    if(this.direction > 0){this.play_animation();}\n",
       "    else if(this.direction < 0){this.reverse_animation();}\n",
       "  }\n",
       "\n",
       "  Animation.prototype.anim_step_forward = function()\n",
       "  {\n",
       "    this.current_frame += 1;\n",
       "    if(this.current_frame < this.frames.length){\n",
       "      this.set_frame(this.current_frame);\n",
       "    }else{\n",
       "      var loop_state = this.get_loop_state();\n",
       "      if(loop_state == \"loop\"){\n",
       "        this.first_frame();\n",
       "      }else if(loop_state == \"reflect\"){\n",
       "        this.last_frame();\n",
       "        this.reverse_animation();\n",
       "      }else{\n",
       "        this.pause_animation();\n",
       "        this.last_frame();\n",
       "      }\n",
       "    }\n",
       "  }\n",
       "\n",
       "  Animation.prototype.anim_step_reverse = function()\n",
       "  {\n",
       "    this.current_frame -= 1;\n",
       "    if(this.current_frame >= 0){\n",
       "      this.set_frame(this.current_frame);\n",
       "    }else{\n",
       "      var loop_state = this.get_loop_state();\n",
       "      if(loop_state == \"loop\"){\n",
       "        this.last_frame();\n",
       "      }else if(loop_state == \"reflect\"){\n",
       "        this.first_frame();\n",
       "        this.play_animation();\n",
       "      }else{\n",
       "        this.pause_animation();\n",
       "        this.first_frame();\n",
       "      }\n",
       "    }\n",
       "  }\n",
       "\n",
       "  Animation.prototype.pause_animation = function()\n",
       "  {\n",
       "    this.direction = 0;\n",
       "    if (this.timer){\n",
       "      clearInterval(this.timer);\n",
       "      this.timer = null;\n",
       "    }\n",
       "  }\n",
       "\n",
       "  Animation.prototype.play_animation = function()\n",
       "  {\n",
       "    this.pause_animation();\n",
       "    this.direction = 1;\n",
       "    var t = this;\n",
       "    if (!this.timer) this.timer = setInterval(function(){t.anim_step_forward();}, this.interval);\n",
       "  }\n",
       "\n",
       "  Animation.prototype.reverse_animation = function()\n",
       "  {\n",
       "    this.pause_animation();\n",
       "    this.direction = -1;\n",
       "    var t = this;\n",
       "    if (!this.timer) this.timer = setInterval(function(){t.anim_step_reverse();}, this.interval);\n",
       "  }\n",
       "</script>\n",
       "\n",
       "<div class=\"animation\" align=\"center\">\n",
       "    <img id=\"_anim_imgXHIYHIFZSYHCCGAW\">\n",
       "    <br>\n",
       "    <input id=\"_anim_sliderXHIYHIFZSYHCCGAW\" type=\"range\" style=\"width:350px\" name=\"points\" min=\"0\" max=\"1\" step=\"1\" value=\"0\" onchange=\"animXHIYHIFZSYHCCGAW.set_frame(parseInt(this.value));\"></input>\n",
       "    <br>\n",
       "    <button onclick=\"animXHIYHIFZSYHCCGAW.slower()\">&#8211;</button>\n",
       "    <button onclick=\"animXHIYHIFZSYHCCGAW.first_frame()\"><img class=\"anim_icon\" src=\"\"></button>\n",
       "    <button onclick=\"animXHIYHIFZSYHCCGAW.previous_frame()\"><img class=\"anim_icon\" src=\"\"></button>\n",
       "    <button onclick=\"animXHIYHIFZSYHCCGAW.reverse_animation()\"><img class=\"anim_icon\" src=\"\"></button>\n",
       "    <button onclick=\"animXHIYHIFZSYHCCGAW.pause_animation()\"><img class=\"anim_icon\" src=\"\"></button>\n",
       "    <button onclick=\"animXHIYHIFZSYHCCGAW.play_animation()\"><img class=\"anim_icon\" src=\"\"></button>\n",
       "    <button onclick=\"animXHIYHIFZSYHCCGAW.next_frame()\"><img class=\"anim_icon\" src=\"\"></button>\n",
       "    <button onclick=\"animXHIYHIFZSYHCCGAW.last_frame()\"><img class=\"anim_icon\" src=\"\"></button>\n",
       "    <button onclick=\"animXHIYHIFZSYHCCGAW.faster()\">+</button>\n",
       "  <form action=\"#n\" name=\"_anim_loop_selectXHIYHIFZSYHCCGAW\" class=\"anim_control\">\n",
       "    <input type=\"radio\" name=\"state\" value=\"once\" > Once </input>\n",
       "    <input type=\"radio\" name=\"state\" value=\"loop\" checked> Loop </input>\n",
       "    <input type=\"radio\" name=\"state\" value=\"reflect\" > Reflect </input>\n",
       "  </form>\n",
       "</div>\n",
       "\n",
       "\n",
       "<script language=\"javascript\">\n",
       "  /* Instantiate the Animation class. */\n",
       "  /* The IDs given should match those used in the template above. */\n",
       "  (function() {\n",
       "    var img_id = \"_anim_imgXHIYHIFZSYHCCGAW\";\n",
       "    var slider_id = \"_anim_sliderXHIYHIFZSYHCCGAW\";\n",
       "    var loop_select_id = \"_anim_loop_selectXHIYHIFZSYHCCGAW\";\n",
       "    var frames = new Array(0);\n",
       "    \n",
       "  frames[0] = \"\"\n",
       "  frames[1] = \"\"\n",
       "  frames[2] = \"\"\n",
       "  frames[3] = \"\"\n",
       "  frames[4] = \"\"\n",
       "  frames[5] = \"\"\n",
       "  frames[6] = \"\"\n",
       "  frames[7] = \"\"\n",
       "  frames[8] = \"\"\n",
       "  frames[9] = \"\"\n",
       "  frames[10] = \"\"\n",
       "  frames[11] = \"\"\n",
       "  frames[12] = \"\"\n",
       "  frames[13] = \"\"\n",
       "  frames[14] = \"\"\n",
       "  frames[15] = \"\"\n",
       "  frames[16] = \"\"\n",
       "  frames[17] = \"\"\n",
       "  frames[18] = \"\"\n",
       "  frames[19] = \"\"\n",
       "  frames[20] = \"\"\n",
       "  frames[21] = \"\"\n",
       "  frames[22] = \"\"\n",
       "  frames[23] = \"\"\n",
       "  frames[24] = \"\"\n",
       "  frames[25] = \"\"\n",
       "  frames[26] = \"\"\n",
       "  frames[27] = \"\"\n",
       "  frames[28] = \"\"\n",
       "  frames[29] = \"\"\n",
       "  frames[30] = \"\"\n",
       "  frames[31] = \"\"\n",
       "  frames[32] = \"\"\n",
       "  frames[33] = \"\"\n",
       "  frames[34] = \"\"\n",
       "  frames[35] = \"\"\n",
       "  frames[36] = \"\"\n",
       "  frames[37] = \"\"\n",
       "  frames[38] = \"\"\n",
       "  frames[39] = \"\"\n",
       "  frames[40] = \"\"\n",
       "  frames[41] = \"\"\n",
       "  frames[42] = \"\"\n",
       "  frames[43] = \"\"\n",
       "  frames[44] = \"\"\n",
       "  frames[45] = \"\"\n",
       "  frames[46] = \"\"\n",
       "  frames[47] = \"\"\n",
       "  frames[48] = \"\"\n",
       "  frames[49] = \"\"\n",
       "  frames[50] = \"\"\n",
       "  frames[51] = \"\"\n",
       "  frames[52] = \"\"\n",
       "  frames[53] = \"\"\n",
       "  frames[54] = \"\"\n",
       "  frames[55] = \"\"\n",
       "  frames[56] = \"\"\n",
       "  frames[57] = \"\"\n",
       "  frames[58] = \"\"\n",
       "  frames[59] = \"\"\n",
       "  frames[60] = \"\"\n",
       "  frames[61] = \"\"\n",
       "  frames[62] = \"\"\n",
       "  frames[63] = \"\"\n",
       "  frames[64] = \"\"\n",
       "  frames[65] = \"\"\n",
       "  frames[66] = \"\"\n",
       "  frames[67] = \"\"\n",
       "  frames[68] = \"\"\n",
       "  frames[69] = \"\"\n",
       "  frames[70] = \"\"\n",
       "  frames[71] = \"\"\n",
       "  frames[72] = \"\"\n",
       "  frames[73] = \"\"\n",
       "  frames[74] = \"\"\n",
       "  frames[75] = \"\"\n",
       "  frames[76] = \"\"\n",
       "  frames[77] = \"\"\n",
       "  frames[78] = \"\"\n",
       "  frames[79] = \"\"\n",
       "  frames[80] = \"\"\n",
       "  frames[81] = \"\"\n",
       "  frames[82] = \"\"\n",
       "  frames[83] = \"\"\n",
       "  frames[84] = \"\"\n",
       "  frames[85] = \"\"\n",
       "  frames[86] = \"\"\n",
       "  frames[87] = \"\"\n",
       "  frames[88] = \"\"\n",
       "  frames[89] = \"\"\n",
       "  frames[90] = \"\"\n",
       "  frames[91] = \"\"\n",
       "  frames[92] = \"\"\n",
       "  frames[93] = \"\"\n",
       "  frames[94] = \"\"\n",
       "  frames[95] = \"\"\n",
       "  frames[96] = \"\"\n",
       "  frames[97] = \"\"\n",
       "  frames[98] = \"\"\n",
       "  frames[99] = \"\"\n",
       "  frames[100] = \"\"\n",
       "  frames[101] = \"\"\n",
       "  frames[102] = \"\"\n",
       "  frames[103] = \"\"\n",
       "  frames[104] = \"\"\n",
       "  frames[105] = \"\"\n",
       "  frames[106] = \"\"\n",
       "  frames[107] = \"\"\n",
       "  frames[108] = \"\"\n",
       "  frames[109] = \"\"\n",
       "  frames[110] = \"\"\n",
       "  frames[111] = \"\"\n",
       "  frames[112] = \"\"\n",
       "  frames[113] = \"\"\n",
       "  frames[114] = \"\"\n",
       "  frames[115] = \"\"\n",
       "  frames[116] = \"\"\n",
       "  frames[117] = \"\"\n",
       "  frames[118] = \"\"\n",
       "  frames[119] = \"\"\n",
       "  frames[120] = \"\"\n",
       "  frames[121] = \"\"\n",
       "  frames[122] = \"\"\n",
       "  frames[123] = \"\"\n",
       "  frames[124] = \"\"\n",
       "  frames[125] = \"\"\n",
       "  frames[126] = \"\"\n",
       "  frames[127] = \"\"\n",
       "  frames[128] = \"\"\n",
       "  frames[129] = \"\"\n",
       "  frames[130] = \"\"\n",
       "  frames[131] = \"\"\n",
       "  frames[132] = \"\"\n",
       "  frames[133] = \"\"\n",
       "  frames[134] = \"\"\n",
       "  frames[135] = \"\"\n",
       "  frames[136] = \"\"\n",
       "  frames[137] = \"\"\n",
       "  frames[138] = \"\"\n",
       "  frames[139] = \"\"\n",
       "  frames[140] = \"\"\n",
       "  frames[141] = \"\"\n",
       "  frames[142] = \"\"\n",
       "  frames[143] = \"\"\n",
       "  frames[144] = \"\"\n",
       "  frames[145] = \"\"\n",
       "  frames[146] = \"\"\n",
       "  frames[147] = \"\"\n",
       "  frames[148] = \"\"\n",
       "  frames[149] = \"\"\n",
       "  frames[150] = \"\"\n",
       "  frames[151] = \"\"\n",
       "  frames[152] = \"\"\n",
       "  frames[153] = \"\"\n",
       "  frames[154] = \"\"\n",
       "  frames[155] = \"\"\n",
       "  frames[156] = \"\"\n",
       "  frames[157] = \"\"\n",
       "  frames[158] = \"\"\n",
       "  frames[159] = \"\"\n",
       "  frames[160] = \"\"\n",
       "  frames[161] = \"\"\n",
       "  frames[162] = \"\"\n",
       "  frames[163] = \"\"\n",
       "  frames[164] = \"\"\n",
       "  frames[165] = \"\"\n",
       "  frames[166] = \"\"\n",
       "  frames[167] = \"\"\n",
       "  frames[168] = \"\"\n",
       "  frames[169] = \"\"\n",
       "  frames[170] = \"\"\n",
       "  frames[171] = \"\"\n",
       "  frames[172] = \"\"\n",
       "  frames[173] = \"\"\n",
       "  frames[174] = \"\"\n",
       "  frames[175] = \"\"\n",
       "  frames[176] = \"\"\n",
       "  frames[177] = \"\"\n",
       "  frames[178] = \"\"\n",
       "  frames[179] = \"\"\n",
       "  frames[180] = \"\"\n",
       "  frames[181] = \"\"\n",
       "  frames[182] = \"\"\n",
       "  frames[183] = \"\"\n",
       "  frames[184] = \"\"\n",
       "  frames[185] = \"\"\n",
       "  frames[186] = \"\"\n",
       "  frames[187] = \"\"\n",
       "  frames[188] = \"\"\n",
       "  frames[189] = \"\"\n",
       "  frames[190] = \"\"\n",
       "  frames[191] = \"\"\n",
       "  frames[192] = \"\"\n",
       "  frames[193] = \"\"\n",
       "  frames[194] = \"\"\n",
       "  frames[195] = \"\"\n",
       "  frames[196] = \"\"\n",
       "  frames[197] = \"\"\n",
       "  frames[198] = \"\"\n",
       "  frames[199] = \"\"\n",
       "\n",
       "\n",
       "    /* set a timeout to make sure all the above elements are created before\n",
       "       the object is initialized. */\n",
       "    setTimeout(function() {\n",
       "        animXHIYHIFZSYHCCGAW = new Animation(frames, img_id, slider_id, 50, loop_select_id);\n",
       "    }, 0);\n",
       "  })()\n",
       "</script>\n"
      ],
      "text/plain": [
       "<IPython.core.display.HTML object>"
      ]
     },
     "metadata": {},
     "output_type": "display_data"
    }
   ],
   "source": [
    "if IN_COLAB:  # for colab\n",
    "    import base64\n",
    "    import glob\n",
    "    import io\n",
    "    import os\n",
    "\n",
    "    from IPython.display import HTML, display\n",
    "\n",
    "    def ipython_show_video(path: str) -> None:\n",
    "        \"\"\"Show a video at `path` within IPython Notebook.\"\"\"\n",
    "        if not os.path.isfile(path):\n",
    "            raise NameError(\"Cannot access: {}\".format(path))\n",
    "\n",
    "        video = io.open(path, \"r+b\").read()\n",
    "        encoded = base64.b64encode(video)\n",
    "\n",
    "        display(HTML(\n",
    "            data=\"\"\"\n",
    "            <video alt=\"test\" controls>\n",
    "            <source src=\"data:video/mp4;base64,{0}\" type=\"video/mp4\"/>\n",
    "            </video>\n",
    "            \"\"\".format(encoded.decode(\"ascii\"))\n",
    "        ))\n",
    "\n",
    "    list_of_files = glob.glob(\"videos/*.mp4\")\n",
    "    latest_file = max(list_of_files, key=os.path.getctime)\n",
    "    print(latest_file)\n",
    "    ipython_show_video(latest_file)\n",
    "\n",
    "else:  # for jupyter\n",
    "    from matplotlib import animation\n",
    "    from JSAnimation.IPython_display import display_animation\n",
    "    from IPython.display import display\n",
    "\n",
    "\n",
    "    def display_frames_as_gif(frames):\n",
    "        \"\"\"Displays a list of frames as a gif, with controls.\"\"\"\n",
    "        patch = plt.imshow(frames[0])\n",
    "        plt.axis('off')\n",
    "\n",
    "        def animate(i):\n",
    "            patch.set_data(frames[i])\n",
    "\n",
    "        anim = animation.FuncAnimation(\n",
    "            plt.gcf(), animate, frames = len(frames), interval=50\n",
    "        )\n",
    "        display(display_animation(anim, default_mode='loop'))\n",
    "\n",
    "\n",
    "    # display \n",
    "    display_frames_as_gif(frames)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": []
  }
 ],
 "metadata": {
  "kernelspec": {
   "display_name": "pg-is-all-you-need",
   "language": "python",
   "name": "pg-is-all-you-need"
  },
  "language_info": {
   "codemirror_mode": {
    "name": "ipython",
    "version": 3
   },
   "file_extension": ".py",
   "mimetype": "text/x-python",
   "name": "python",
   "nbconvert_exporter": "python",
   "pygments_lexer": "ipython3",
   "version": "3.6.9"
  }
 },
 "nbformat": 4,
 "nbformat_minor": 4
}
